COMPILATION LISTING OF SEGMENT io_data_list_semantics Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-05-05_1826.81_Fri_mdt Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 io_data_list_semantics:proc(b,s_param,t_param); 12 13 /* updated 12-11-72 by PAB to make way for pictures */ 14 /* Modified 780616 by PG for unsigned */ 15 /* Modified Dec 1978 by David Spector for new 'set' xref format */ 16 17 18 19 20 dcl (trans_op,format_op) bit(9) aligned; /* particular transmission operator */ 21 dcl context_with_top_bit_on bit(36) init("000001000000000000000000000000000000"b) 22 internal static options(constant) aligned; 23 dcl decode_complex_fun(2) bit(9) aligned init(real_fun,imag_fun); 24 25 dcl p_str char(256) varying aligned; 26 dcl prefix bit(12) aligned; 27 dcl (p,q,r,s,tt,tp,jp,op,bx,vp,pa_ptr,rr,pp,wp,vs,uncomplex_temp,format_ptr,length_ptr,ip,c_format_ptr,q2, 28 loop_ptr) ptr; 29 30 dcl ctl_pointer(64) ptr unaligned; 31 32 dcl 1 format_list_ptr_table(64) aligned, 33 2 it_factor fixed bin(31), 34 2 f_ptr pointer unaligned; 35 dcl (nss,ri,sy) ptr; 36 dcl (i,j,ki,k,n,constant_operands,pti,ctli,wi,si,de,pa_opnum, 37 peti,first_peti,op_num,var_cnt,num_eaten,data_item_index,cur_rep,ctl_cnt) fixed bin(15) ; 38 dcl c_length fixed bin (31); 39 dcl bbin35 fixed bin(35) based; 40 dcl (null,string,substr,hbound) builtin; 41 dcl pl1_stat_$ok_list ptr external; 42 dcl (get_of_noncomputational,data_format_found) bit(1) aligned ; 43 dcl no_quick_edit bit(1) aligned init("0"b); /* flag to disqualify put_edit_trans's from becoming put_fields */ 44 dcl (b,s_param,t_param) ptr; 45 dcl t ptr; 46 dcl (flt,fltt) ptr; 47 dcl (fop,pa_type) bit(9) aligned; 48 49 50 /* program */ 51 52 s=s_param; 53 prefix=s->statement.prefix; 54 t=t_param; 55 nss=s->statement.next; 56 trans_op=t->operator.op_code; 57 jp=t->operator.operand(1); 58 59 if trans_op=get_data_trans then goto get_data_; 60 61 if trans_op=get_edit_trans then goto edit_loop_; 62 if trans_op=put_edit_trans then goto edit_loop_; 63 64 if jp=null 65 then if trans_op=put_data_trans 66 then do; 67 bx=b; 68 do while(bx^=null); 69 bx->block.get_data="1"b; /* this means put block in S.T. */ 70 bx=bx->block.father; 71 end; 72 end; 73 else; 74 else call io_join_semantics(jp); 75 76 exit: return; 77 78 edit_loop_: 79 80 81 82 r=create_statement(assignment_statement,(nss->statement.back),null,prefix); 83 /* make a format statement, 84* set PS.newformat and set PS.special_list_p=addr(format) */ 85 86 if b->block.plio_ps->list.element(32) = null /* ps.new_format is unique in that both compiled */ 87 then do; /* code and plio runtime touch it. Therefore we */ 88 tt=create_symbol(null,null,by_compiler);/* cant let the optim. remove apparently redundent*/ 89 tt->symbol.binary, /* assgnmts to it in the code. To do this we */ 90 tt->symbol.fixed, /* create a dummy symbol defined on it,thereby */ 91 tt->symbol.aligned, /* making ps.new_format aliasable and hence */ 92 tt->symbol.overlayed, /* unoptimizable. */ 93 tt->symbol.aliasable, 94 tt->symbol.defined="1"b; 95 tt->symbol.c_dcl_size=15; 96 call declare(tt); 97 98 rr=tt->symbol.reference; 99 rr->reference.units=word_; 100 rr->reference.c_offset=30; 101 rr->reference.qualifier=copy_expression((b->block.plio_ps->list.element(1)->symbol.reference)); 102 b->block.plio_ps->list.element(32)=rr; 103 end; 104 105 r->statement.processed,r->statement.generated="1"b; 106 107 r->statement.root,tt=create_operator(join,2); 108 op,tt->operator.operand(1)=create_operator(assign,2); 109 op->operator.operand(2)=declare_constant$integer(1); 110 op->operator.operand(1)=b->block.plio_ps->list.element(ps_new_format+2); 111 112 op,tt->operator.operand(2)=create_operator(assign,2); 113 op->operator.operand(1)=b->block.plio_ps->list.element(ps_special_list+2); 114 q,op->operator.operand(2)=create_operator(addr_fun,2); 115 q->operator.operand(1)=declare_temporary(pointer_type,0,0,null); 116 r=create_statement(format_statement,(nss->statement.back),null,prefix); 117 r->statement.processed,r->statement.generated="1"b; 118 tp=create_symbol(b,null,by_compiler); 119 tp->symbol.constant,tp->symbol.format="1"b; 120 tp->symbol.initial=r; /* points at the format statement */ 121 q->operator.operand(2)=tp->symbol.reference; 122 tp,r->statement.root=t->operator.operand(2); /* format list */ 123 call io_data_list_semantics$format_list_semantics(b,r,tp); 124 125 126 127 call io_join_semantics(jp); 128 129 130 end_edit_loop_: 131 if trans_op=put_edit_trans /* try to replace slow put_edit_tras with fast put_fields */ 132 then if ^no_quick_edit then do; 133 pti = 0; 134 call format_list_process(tp); /* which builds an array of simple format items */ 135 goto make_quick_puts; /* which replace the put_edit_tras */ 136 end; 137 punt: 138 exit_2: 139 if t->operator.operand(3)=null then goto exit; 140 t=t->operator.operand(3); /* next (DL)(FL) pair */ 141 jp=t->operator.operand(1); 142 goto edit_loop_; 143 144 /* */ 145 /* This block of code creates a series of put_fields and put_field_chks instead of the orig. put_edit_tras */ 146 147 148 make_quick_puts: 149 150 string(context) = "0"b; 151 152 r->statement.next->statement.root = expression_semantics(b,s_param,(r->statement.next->statement.root),context); 153 154 jp = r->statement.next->statement.root; 155 156 if jp->operator.op_code = join 157 then var_cnt = jp->operator.number; 158 else var_cnt = 1; 159 160 cur_rep = 0; 161 ctl_cnt = 0; 162 peti = 0; 163 data_format_found = "0"b; 164 do data_item_index = 1 to var_cnt; 165 166 next_format: 167 call get_next_format; /* this subroutine sets format_op */ 168 if format_op >= x_format 169 then if format_op <= line_format 170 then do; 171 ctl_cnt = ctl_cnt+1; 172 if ctl_cnt>64 then goto punt; 173 goto next_format; 174 end; 175 176 data_format_found = "1"b; 177 ctl_cnt = 0; 178 if jp->operator.op_code=join /* jp points to the root of the ass. stat. after the format stat */ 179 then vp = jp->operand(data_item_index); 180 else vp = jp; 181 182 if vp->node.type ^= operator_node 183 then goto err495; 184 185 if vp->operator.op_code ^= put_edit_trans 186 then do; 187 if vp->operator.op_code = do_fun 188 then goto punt; /* an implied do-loop was here */ 189 if vp->operator.op_code = join 190 then goto punt; /* a structure was found here */ 191 /* maybe can be handled in future,one problem */ 192 /* is knowing length of output of conversion */ 193 194 if vp->operator.op_code = loop 195 then do; /* an array was expanded here */ 196 197 num_eaten = expand_loop_set_ptr(vp,vp,ip); /* the ip arg is a dummy, we dont use it here */ 198 first_peti = peti; 199 do i = 1 to (num_eaten-1); 200 call get_next_format; 201 if format_list_ptr_table(first_peti).f_ptr ^= 202 format_list_ptr_table(peti).f_ptr 203 then if ^compare_format((format_list_ptr_table(first_peti).f_ptr), 204 (format_list_ptr_table(peti).f_ptr)) 205 then goto punt; /* not all conversions for this item = */ 206 end; 207 end; 208 else goto err495; 209 end; 210 end; 211 cur_rep = 0; 212 ctl_cnt = 0; 213 peti = 0; 214 do data_item_index = 1 to var_cnt; 215 216 next_format_this_data_item: 217 218 call get_next_format; 219 op_num = format_ptr->operator.number; 220 if format_op = skip_format 221 then ctli = 1; 222 else if format_op = column_format 223 then ctli = 2; 224 else if format_op = page_format 225 then ctli = 3; 226 else if format_op = line_format 227 then ctli = 4; 228 else if format_op = x_format /* I treat it as a control format */ 229 then ctli = 5; 230 else ctli = 0; /* not a control format */ 231 232 if ctli>0 233 then do; 234 pp = create_operator(put_control,2); 235 pp->operand(1) = declare_constant$integer((ctli)); 236 if op_num > 2 237 then pp->operand(2)=copy_unique_expression((format_ptr->operand(3))); 238 else pp->operand(2)=declare_constant$integer(1); /* we'll be safe but some error checking could be done here */ 239 ctl_cnt = ctl_cnt + 1; 240 ctl_pointer(ctl_cnt) = pp; 241 goto next_format_this_data_item; 242 end; 243 244 else do; 245 246 do op_num = op_num repeat op_num-1 while (format_ptr->operand(op_num) = null); 247 end; /* treat null operands as if they dont exist & apply the defaults */ 248 if jp->operator.op_code=join /* jp points to the root of the ass. stat. after the format stat */ 249 then do; 250 pa_type = operator_node; 251 pa_opnum = data_item_index; 252 pa_ptr = jp; 253 ip = jp->operand(data_item_index); 254 end; 255 else do; 256 pa_type = statement_node; 257 pa_ptr = r->statement.next; 258 ip = jp; 259 end; 260 261 if ip->operator.op_code = put_edit_trans 262 then do; 263 vp = ip->operand(2); 264 loop_ptr = null; 265 end; 266 else do; /* we have a loop operator here,meaning an array */ 267 num_eaten = expand_loop_set_ptr(ip,vp,loop_ptr); 268 do i = 1 to (num_eaten-1); 269 call get_next_format; 270 end; 271 end; 272 273 if format_op = a_format 274 | format_op = b_format 275 then do; 276 277 if format_op=a_format 278 then pp = vp; 279 else pp= convert$from_builtin(vp,bit_type); /* convert the string to bits */ 280 p = create_operator(put_field,2); 281 282 if op_num > 2 /* means there is a length given */ 283 then do; 284 if format_ptr->operand(3)->node.type = reference_node 285 then if format_ptr->operand(3)->reference.symbol->symbol.constant 286 then do; /* declare the temporary with this constant length */ 287 c_length = format_ptr->operand(3)->reference.symbol->symbol.initial->bbin35; 288 length_ptr = null; /* no dcl_size if there is a c_dcl_size */ 289 goto lengths_set; 290 end; 291 292 /* needs a dcl_size & a c_dcl_size of zero */ 293 c_length = 0; 294 length_ptr = copy_unique_expression((format_ptr->operand(3))); 295 lengths_set: 296 p->operand(2) = convert$to_target_fb(pp,declare_temporary(char_type, 297 c_length,0,length_ptr)); 298 end; /* the target temp. assignment does the check for size cond. */ 299 else p->operand(2) = convert$from_builtin(pp,char_type); /* no length, no check */ 300 301 if p->operand(2)->node.type=operator_node 302 then pp = p->operand(2)->operand(1); 303 else pp = p->operand(2); 304 305 if op_num > 2 306 then if length_ptr = null 307 then wp = format_ptr->operand(3); /* just use op(3) for width */ 308 else wp = share_expression(length_ptr); 309 else if pp->reference.varying_ref 310 then do; 311 wp = create_operator(length_fun,2); 312 wp->operand(1) = declare_temporary(integer_type,max_length_precision, 313 0,null); 314 wp->operand(2) = share_expression((p->operand(2))); 315 end; 316 else if pp->reference.length = null /* use ref length */ 317 then wp = declare_constant$integer((pp->reference.c_length)); 318 else wp = share_expression((pp->reference.length)); 319 p->operand(1) = wp; /* op(1) of put_field is length of output string */ 320 end; 321 322 else if ^pef_format(vp) /* must be complex (c_format) format item */ 323 then do; 324 if vp->node.type = operator_node 325 then vs = vp->operand(1)->reference.symbol; 326 else vs = vp->reference.symbol; 327 c_format_ptr = format_ptr; 328 wp = create_operator(join,2); 329 if vs->symbol.complex 330 then do; 331 uncomplex_temp = declare_temporary(substr(string(vs->symbol.attributes),1,36) 332 & ^unaligned_mask & ^complex_mask | aligned_mask | real_mask, 333 (vs->symbol.c_dcl_size), (vs->symbol.scale), null); 334 do j = 1 to 2; 335 call get_next_part_of_cplx_format(j+2); 336 q = create_operator(decode_complex_fun(j),2); 337 q->operator.processed = "1"b; 338 q->operand(1) = uncomplex_temp; 339 if j = 1 340 then q->operand(2) = vp; 341 else q->operand(2) = share_expression(vp); 342 if ^pef_format(q) 343 then goto err170; 344 wp->operand(j) = p; 345 end; 346 end; 347 348 else if vs->symbol.char 349 then do j = 1 to 2; 350 /* The point of this code is to change the temp on the LHS */ 351 /* of the bottom assign_op to a complex version of itself, and */ 352 /* to insert a real or imag operator above that assign_op, */ 353 /* with the old version of the temp on it's LHS */ 354 call get_next_part_of_cplx_format(j+2); 355 if j = 1 356 then if ^pef_format(vp) 357 then goto err170; 358 else; 359 else if ^pef_format(share_expression(vp)) 360 then goto err170; 361 q = p->operand(2)->operand(2)->operand(1); 362 p->operand(2)->operand(2)->operand(1) = force_cplx_temp(q); 363 q2 = create_operator(decode_complex_fun(j),2); 364 q2->operator.processed = "1"b; 365 q2->operand(1) = q; 366 q2->operand(2) = p->operand(2)->operand(2); 367 p->operand(2)->operand(2) = q2; 368 wp->operand(j) = p; 369 end; 370 371 else do; 372 call get_next_part_of_cplx_format(3); 373 if ^pef_format(vp) then goto err170; 374 wp->operand(1) = p; 375 call get_next_part_of_cplx_format(4); 376 if ^pef_format(create_token("0",dec_integer)) then goto err170; 377 wp->operand(2) = p; 378 end; 379 380 381 382 p = wp; 383 end; 384 385 if ctl_cnt>0 386 then do; 387 pp = create_operator(join,(ctl_cnt+1)); 388 do j=1 to ctl_cnt; 389 pp->operand(j)=ctl_pointer(j); 390 end; 391 if loop_ptr = null 392 then pp -> operand(ctl_cnt+1) = p; 393 else do; 394 loop_ptr -> operand(1) = p; 395 pp -> operand(ctl_cnt+1) = ip; 396 end; 397 p=pp; 398 ctl_cnt = 0; 399 end; 400 else if loop_ptr ^= null 401 then do; 402 loop_ptr -> operand(1) = p; 403 p = ip; 404 end; 405 406 if pa_type = statement_node 407 then pa_ptr->statement.root = p; 408 else pa_ptr->operator.operand(pa_opnum) = p; 409 end; 410 end; 411 412 goto exit_2; 413 414 /* */ 415 expand_loop_set_ptr:proc(op_param,vp_param,pa_param) returns(fixed bin (31)); 416 417 dcl (op_ptr,op_param,vp_param,pa_param) pointer; 418 419 op_ptr=op_param; 420 if op_ptr->operator.operand(4)->node.type ^= reference_node 421 then goto punt; 422 423 if ^op_ptr->operator.operand(4)->reference.symbol->symbol.constant 424 then goto punt; 425 else if op_ptr->operator.operand(1)->operator.op_code = put_edit_trans 426 then do; 427 pa_param = op_ptr; 428 vp_param = op_ptr->operator.operand(1)->operator.operand(2); 429 return((op_ptr->operator.operand(4)->reference.symbol->symbol.initial->bbin35)); 430 end; 431 432 else if op_ptr->operator.operand(1)->operator.op_code = loop 433 then return((op_ptr->operator.operand(4)->reference.symbol->symbol.initial 434 ->bbin35 * expand_loop_set_ptr((op_ptr->operator.operand(1)),vp_param,pa_param))); 435 else goto punt; 436 437 end expand_loop_set_ptr; 438 439 440 441 /* Sees if format list is entirely known at compile time and produces an expanded array of simple format items */ 442 443 444 format_list_process:proc(p_param); 445 446 dcl (h,iteration_factor,i,j) fixed bin, (p,p_param,q) ptr; 447 448 do p = p_param repeat p->operand(1) while (p ^= null); 449 450 if p->operator.op_code=e_format /* e,f_formats need the creation of a picture so all */ 451 | p->operator.op_code=f_format /* fields must be known at compile time, for the others */ 452 then constant_operands=p->operator.number; /* only the iteration factor must be known. */ 453 else if p->operator.op_code = r_format 454 then constant_operands = 3; 455 else constant_operands=2; 456 457 do i = 2 to constant_operands; 458 if p->operand(i) ^= null 459 then if p->operand(i)->node.type ^= reference_node 460 then goto punt; 461 else if ^p->operand(i)->reference.symbol->symbol.constant 462 then goto punt; /* Throughout this proc as soon as we give up on quick i/o we */ 463 end; /* just goto punt. */ 464 465 if p->operand(2) ^= null 466 then iteration_factor = p->operand(2)->reference.symbol->symbol.initial->bbin35; 467 else iteration_factor=1; 468 if p->operator.op_code = r_format 469 then do; 470 q2 = p->operand(3)->reference.symbol; 471 q2->symbol.initial->statement.root, 472 q = expression_semantics((q2->symbol.block_node),(q2->symbol.initial), 473 (q2->symbol.initial->statement.root),(context_with_top_bit_on)); 474 /* the last arg MUST be passed by value cause it is an */ 475 /* in/out arg yet dcl'd options(constant) !!! */ 476 do j=1 to iteration_factor; 477 call format_list_process(q); 478 end; 479 end; 480 else if p->operator.op_code = l_parn 481 then do; 482 q = p->operand(3); /* operand(3) is the true format item */ 483 do j=1 to iteration_factor; 484 call format_list_process(q); 485 end; 486 end; 487 488 else do; 489 if p->operator.op_code = c_format 490 then do; 491 /* op(3) is real form. item, op(4) is imag form. item */ 492 if p->operator.number = 2 then goto punt; 493 494 do h=3 to p->operator.number; 495 496 if p->operand(h)->operand(2) ^= null then goto punt; 497 do k=3 to p->operand(h)->operator.number; 498 if p->operand(h)->operand(k)^=null 499 then if p->operand(h)->operand(k)->node.type ^= reference_node 500 then goto punt; 501 else if ^p->operand(h)->operand(k)->reference.symbol->symbol.constant 502 then goto punt; 503 end; 504 505 end; 506 end; 507 else if p->operator.op_code = bn_format 508 then goto punt; 509 else if p->operator.op_code=e_format 510 then if p->operator.number > 4 511 then if p->operand(5)^=null 512 then if p->operand(5)->reference.symbol->symbol.initial 513 ->bbin35 <= p->operand(4)->reference.symbol->symbol.initial 514 ->bbin35 515 then goto punt; /* sig digits < dec prec !! */ 516 517 518 if pti>hbound(format_list_ptr_table,1)-1 then goto punt; 519 pti = pti+1; 520 format_list_ptr_table(pti).it_factor = iteration_factor; 521 format_list_ptr_table(pti).f_ptr = p; 522 end; 523 524 end; 525 end; 526 527 528 /* */ 529 /* Process p_format,e_format,f_format items, return "0"b if not one of those types. */ 530 531 532 pef_format:proc(vp_param) returns(bit(1) aligned); 533 534 dcl (vp,vp_param) ptr; 535 536 vp = vp_param; 537 538 if format_op=f_format 539 then do; 540 541 if op_num > 3 /* op(4) is the decimal precision (de) */ 542 then de = format_ptr->operand(4)->reference.symbol->symbol.initial->bbin35; 543 else de = 0; /* 0 is the default decimal precision */ 544 if op_num > 4 /* op(5) is the scale factor (ki) */ 545 then ki = format_ptr->operand(5)->reference.symbol->symbol.initial->bbin35; 546 else ki = 0; /* 0 is the default scale factor */ 547 wi = format_ptr->operand(3)->reference.symbol->symbol.initial->bbin35; /* op(3) is the field width (wi)*/ 548 549 if de<0 /* These are language defined errors. */ 550 then goto err496; 551 else if wi<0 552 then goto err496; 553 else if wi=0 554 then goto ef_null; 555 else if de>0 556 then if wioperand(1) = declare_constant$integer((rr->reference.c_length-1)); 566 p->operand(2) = convert$to_target_fb(vp,rr); 567 if p->operand(2)->operand(2)->node.type = operator_node 568 then if p->operand(2)->operand(2)->operator.op_code = assign 569 then p->operand(2)->operand(2)->operator.op_code = assign_round; 570 p->operand(3) = declare_constant$integer((wi-min(max_p_dec,wi))); 571 return("1"b); 572 end; 573 574 if format_op = e_format 575 then do; 576 577 wi = format_ptr->operand(3)->reference.symbol->symbol.initial->bbin35; 578 if wi = 0 then goto ef_null; 579 if op_num > 3 580 then de = format_ptr->operand(4)->reference.symbol->symbol.initial->bbin35; 581 else do; 582 p = convert$from_builtin(vp,(float_mask|decimal_mask|aligned_mask|real_mask)); 583 if p->node.type = operator_node 584 then p = p->operand(1); 585 de = p->reference.symbol->symbol.c_dcl_size-1; 586 end; 587 if op_num > 4 588 then si = format_ptr->operand(5)->reference.symbol->symbol.initial->bbin35; 589 else si = de+1; 590 591 if de=0 592 then if si<0 593 then goto err496; 594 else if wi-si-5<0 595 then goto err496; 596 else; 597 else if si-de<0 598 then goto err496; 599 else if wi-si-6<0 600 then goto err496; 601 602 if de ^= 0 603 then p = create_pic_ass_pf(copy("b",wi-si-6)||copy("-",si-de)||"9.v" 604 ||copy("9",de)||"es999",vp,0,"0"b,"1"b); 605 else p = create_pic_ass_pf(copy("b",wi-si-5)||copy("-",si)||"9ves999",vp,0,"0"b,"1"b); 606 return("1"b); 607 end; 608 if format_op = picture_format 609 then do; 610 p = format_ptr->operand(3)->reference.symbol; 611 p_str = string(p->symbol.initial->picture_image.chars); 612 p = create_pic_ass_pf(p_str,vp,(p->symbol.initial->picture_image.scalefactor),"0"b,"0"b); 613 /* The complex bit, arg 3, can be "0"b because there is no such thing as a complex */ 614 /* picture in a format list -- there is no way to express it in a pl1 program */ 615 return("1"b); 616 end; 617 return("0"b); 618 619 ef_null: 620 p = create_operator(nop,0); 621 return("1"b); 622 623 err496: 624 k = 496; 625 call semantic_translator$abort(k,null); 626 end; 627 628 /* */ 629 create_pic_ass_pf:proc(v_str,vq,scalefac,complex_bit,pfc) returns(ptr); 630 631 dcl (p,q,vq) pointer; 632 dcl scalefac fixed bin(31); 633 dcl v_str char(256) varying aligned; 634 dcl (pfc,complex_bit) bit(1) aligned; 635 636 q = declare_picture_temp((v_str),scalefac,complex_bit,"0"b); 637 if pfc 638 then do; 639 p = create_operator(put_field_chk,3); 640 p->operand(1) = declare_constant$integer((q->reference.c_length-1)); 641 p->operand(3) = declare_constant$integer(0); 642 end; 643 else do; 644 p = create_operator(put_field,2); 645 p->operand(1) = declare_constant$integer((q->reference.c_length)); 646 end; 647 648 p->operand(2) = convert$to_target_fb(vq,q); 649 return(p); 650 end; 651 /* */ 652 format_list_semantics:entry(b,s_param,t); 653 654 b -> block.why_nonquick.format_statement = "1"b; 655 b -> block.no_stack = "0"b; 656 657 fop=t->operator.op_code; 658 659 do i=1 to t->operator.number; 660 flt=t->operand(i); 661 if flt=null then goto end_f_loop; 662 663 if i=1 then 664 do; 665 f_list: 666 call io_data_list_semantics$format_list_semantics(b,s_param,flt); 667 goto end_f_loop; 668 end; 669 670 if i=2 then 671 do; 672 int: 673 if flt->node.type=token_node 674 then if flt->token.type^=is_identifier then goto convert_to_integer; 675 fl_process: 676 string(context)="0000"b; 677 flt = expression_semantics(b,s_param,flt,context); 678 call make_non_quick (flt, "0001"b); /* block.why_nonquick.invoked_by_format */ 679 680 convert_to_integer: 681 flt=convert$to_target(flt,declare_temporary(integer_type,default_fix_bin_p,0,null)); 682 goto end_f_loop; 683 end; 684 685 if i=3 then 686 do; 687 if fop=l_parn then goto f_list; 688 if fop=r_format then 689 do; 690 string(context)="0000"b; 691 flt = expression_semantics(b,s_param,flt,context); 692 if def_context.aggregate then goto err171; 693 call make_non_quick (flt, "0001"b); /* block.why_nonquick.invoked_by_format */ 694 if flt->node.type=operator_node then fltt=flt->operand(1); 695 else fltt=flt; 696 if fltt->node.type^=reference_node then goto err171; 697 if ^fltt->reference.symbol->symbol.format then goto err171; 698 goto end_f_loop; 699 end; 700 701 if fop=c_format then 702 do; 703 c_form: 704 if flt->node.type^=operator_node then goto err170; 705 if flt->operator.op_code^=e_format then 706 if flt->operator.op_code^=f_format then 707 if flt->operator.op_code^=picture_format then goto err170; 708 goto f_list; 709 end; 710 if fop=picture_format then goto end_f_loop; /* pc is e reference node already */ 711 goto int; 712 end; 713 714 if i=4 & fop=c_format then goto c_form; 715 goto int; /* all other cases require an integer */ 716 717 err171: 718 k=171; 719 goto sig_format_err; 720 721 err170: 722 k=170; 723 sig_format_err: 724 call semantic_translator$error(k,null); 725 726 end_f_loop: 727 t->operand(i)=flt; 728 end; 729 730 return; 731 732 /* */ 733 get_data_: 734 /* the whole job is done here; we produce 735* directly for code generator. */ 736 737 if jp=null then /* (gdt(1))=null means oklist=const(0) */ 738 do; 739 jp,t->operand(1)=create_operator(join,0); 740 goto full_symtab; 741 end; 742 n=jp->operator.number; 743 if n=0 then 744 do; 745 full_symtab: 746 bx=b; 747 do while(bx^=null); 748 bx->block.get_data="1"b; 749 bx=bx->block.father; 750 end; 751 goto gdexit; 752 end; 753 754 do i=1 to n; 755 /* in each case make sure that the operand is 756* (a) reference to a variable, not to a constant or expression 757* (b) that the ref is not subscripted or qualified 758* i.e., no p->x or x(j,4) 759* (c) that ref is string/arith 760* (d) or is array/structure of string/arith 761* and set "set" and "put_in_symtab" for ref and ref's containing structures 762* */ 763 ri=jp->operand(i); 764 if ri->node.type=token_node then 765 do; 766 string(context)="0"b; 767 ri = expression_semantics(b,s,ri,context); 768 if ri->node.type ^= reference_node then goto err469; 769 goto gdcommon; 770 end; 771 if ri->node.type ^= reference_node then goto err469; 772 if ri->reference.qualifier ^= null then goto err469; 773 if ri->reference.offset ^= null then goto err469; 774 string(context)="0"b; 775 ri = expression_semantics(b,s,ri,context); 776 777 /* ******************************** 778* * 779* * There is an unexplained problem 780* * with defined items. BASIS says 781* * that any defined item is OK here, 782* * AG94 allows string-overlay and 783* * non-asterisk simple defined. 784* * 785* ************************************ */ 786 787 788 gdcommon: 789 /* there were no subscripts or qualifiers */ 790 sy=ri->reference.symbol; 791 792 if def_context.aggregate then if sy->symbol.defined 793 then ri=defined_reference(b,s,ri,null,sy,"0"b); 794 795 796 call walk(sy); 797 if get_of_noncomputational 798 then go to err470; 799 800 go to ok; 801 802 err469: 803 k=469; 804 if ri->node.type^=reference_node then 805 do; 806 k=473; /* err470 is called only with a reference */ 807 sy=null; 808 end; 809 else sy=ri->reference.symbol; 810 goto gderr; 811 812 err470: 813 k=470; 814 gderr: 815 call semantic_translator$error(k,sy); 816 ri=null; 817 ok: 818 jp->operand(i)=ri; /* it has been altered by expression semantics */ 819 end; 820 gdexit: 821 bx=create_list(2); 822 bx->list.element(1)=pl1_stat_$ok_list; 823 pl1_stat_$ok_list=bx; 824 bx->list.element(2)=jp; 825 /* making a list of the oklists as 826* (next,join) pairs */ 827 goto exit; 828 829 /* */ 830 831 832 walk: proc(sp); 833 dcl (sp,tp) ptr; 834 835 get_of_noncomputational = "0"b; 836 837 tp=sp->symbol.father; 838 do while (tp^=null); 839 tp->symbol.put_in_symtab, 840 tp->symbol.set="1"b; 841 if tp->symbol.cross_references ^= null 842 then tp->symbol.cross_references->cross_reference.set_reference = "1"b; 843 tp=tp->symbol.father; 844 end; 845 846 down: entry(sp); 847 848 sp->symbol.put_in_symtab, 849 sp->symbol.set="1"b; 850 tp = sp -> symbol.cross_references; 851 if tp ^= null then tp -> cross_reference.set_reference = "1"b; 852 853 tp=sp->symbol.son; 854 if tp = null /* at bottom? */ 855 then if (substr (string (sp -> symbol.attributes), 1, 36) & computational_mask) = ""b 856 then get_of_noncomputational = "1"b; 857 858 do while (tp ^= null); 859 call down(tp); 860 tp=tp->symbol.brother; 861 end; 862 return; 863 864 end walk; 865 866 867 868 869 870 871 872 label_of_statement: proc(s) returns(ptr); 873 /* returns ptr to label of statement which is created 874* and whose address is returned in "s" */ 875 dcl (s,r) ptr; 876 s=create_statement(assignment_statement,(nss->statement.back),null,prefix); 877 s->statement.processed,s->statement.generated="1"b; 878 879 r=create_label(b,null,by_compiler); 880 r->label.statement=s; 881 s->statement.labels=create_list(2); 882 s->statement.labels->list.element(2)=r; 883 return(r); 884 end; 885 886 /* */ 887 io_join_semantics: proc(t); 888 889 dcl t ptr; 890 891 dcl (randi,s,op,q,tt) ptr; 892 dcl (i,j,k,l,m,n) fixed bin(15); 893 894 j=1; 895 if t=null then goto join_finish; 896 n=t->operator.number; 897 898 join_loop: 899 do i=j to n; 900 randi=t->operand(i); 901 if randi->node.type=operator_node then 902 if randi->operator.op_code=do_fun 903 then do; 904 k=i-1; 905 no_quick_edit = "1"b; 906 goto new_join; 907 end; 908 op=create_operator(trans_op,2); 909 op->operand(2)=randi; 910 911 912 913 914 915 t->operand(i)=op; /* we insert transmission operator */ 916 end; 917 k=n; 918 919 new_join: 920 /* if no elements, nothing 921* if one element, no join: direct "assignment" 922* if >1 elements, make a new join, but 923* if n elements, use original join */ 924 925 l=k+1-j; 926 if l=0 then goto process_do; 927 928 s=create_statement(assignment_statement,(nss->statement.back),null,prefix); 929 s->statement.generated="1"b; 930 931 if l=1 then 932 do; 933 s->statement.root=t->operand(j); 934 goto process_do; 935 end; 936 if l=n then /* simple join */ 937 do; 938 s->statement.root=t; 939 goto join_finish; 940 end; 941 942 s->statement.root, 943 q=create_operator(join,l); 944 945 do m=1 to l; 946 q->operand(m)=t->operand(m+j-1); 947 end; 948 949 process_do: 950 if k=n then goto join_finish; 951 952 s=create_statement(do_statement,(nss->statement.back),null,prefix); 953 s->statement.generated="1"b; 954 s->statement.root=randi; 955 tt=randi->operand(1); 956 call io_join_semantics(tt); 957 958 959 randi->operand(1)=label_of_statement(s); 960 s->statement.processed="0"b; /* ? */ 961 s->statement.statement_type=null_statement; 962 963 j=k+2; 964 if j>n then goto join_finish; /* skipping over the "do" leaves nothing */ 965 goto join_loop; 966 967 join_finish: 968 969 end io_join_semantics; 970 /* */ 971 get_next_format:proc ; 972 973 do while (cur_rep = 0); 974 peti = peti + 1; 975 if peti> pti 976 then do; 977 if ^data_format_found then goto err497; 978 peti = 1; 979 end; 980 cur_rep = format_list_ptr_table(peti).it_factor; 981 end; 982 983 cur_rep = cur_rep-1; 984 985 format_ptr = format_list_ptr_table(peti).f_ptr; 986 format_op = format_ptr->operator.op_code; 987 988 end; 989 /* */ 990 compare_format: proc(pa,pb) returns(bit(1) aligned); 991 992 dcl (pa,pb,a,b) ptr; 993 dcl i fixed bin; 994 995 /* since operand(1) is chain ptr and operand(2) is iteration factor, 996* only operands(3-n) are significant for us. */ 997 998 a = pa; 999 b = pb; 1000 1001 if a = b then return("1"b); 1002 1003 if a ^= null 1004 then if b ^= null 1005 then if a -> operator.op_code = b -> operator.op_code 1006 then if a -> operator.number = b -> operator.number 1007 then do; 1008 do i = 3 to b -> operator.number; 1009 if a -> operand(i) ^= b -> operand(i) 1010 then if ^ compare_expression((a -> operand(i)),(b -> operand(i))) 1011 then go to fail; 1012 end; 1013 return("1"b); 1014 end; 1015 1016 fail: return("0"b); 1017 1018 end; 1019 /* */ 1020 1021 1022 err495: 1023 k = 495; 1024 goto idl_err; 1025 err497: 1026 k = 497; 1027 goto idl_err; 1028 err427: 1029 k = 427; 1030 idl_err: 1031 call semantic_translator$abort(k,null); 1032 1033 1034 1035 /* */ 1036 force_cplx_temp:proc(q_param) returns(ptr); 1037 1038 dcl (q,q_param) ptr; 1039 1040 q = q_param; 1041 return(declare_temporary(substr(string(q->reference.symbol-> 1042 symbol.attributes),1,36) & ^unaligned_mask & ^real_mask 1043 | aligned_mask | complex_mask,(q->reference.symbol-> 1044 symbol.c_dcl_size),(q->reference.symbol->symbol.scale), 1045 null)); 1046 1047 end; 1048 1049 get_next_part_of_cplx_format:proc(num); 1050 dcl num fixed bin(31); 1051 1052 if c_format_ptr->operator.number < num 1053 then return; 1054 1055 format_ptr = c_format_ptr->operand(num); 1056 format_op = format_ptr->operator.op_code; 1057 do op_num = format_ptr->operator.number repeat op_num-1 while(format_ptr->operand(op_num) = null); 1058 end; 1059 1060 return; 1061 1062 end; 1063 1064 /* include files */ 1065 1 1 /* BEGIN INCLUDE FILE ... semant.incl.pl1 */ 1 2 1 3 /* Modified: 30 Aug 1979 by PCK to fix 1804 and 1823 */ 1 4 /* Modified: 26 Aug 1979 by PCK to implement by name assignment */ 1 5 1 6 1 7 declare alloc_semantics entry(pointer,pointer,pointer); 1 8 /* parameter 1: (input) block node pointer */ 1 9 /* parameter 2: (input) statement node pointer */ 1 10 /* parameter 3: (in/out) tree pointer */ 1 11 1 12 declare alloc_semantics$init_only entry(pointer,pointer,pointer); 1 13 /* parameter 1: (input) qualifier pointer */ 1 14 /* parameter 2: (input) statement node pointer */ 1 15 /* parameter 3: (input) symbol node pointer */ 1 16 1 17 declare builtin entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned) 1 18 returns(pointer); 1 19 /* parameter 1: (input) block node pointer */ 1 20 /* parameter 2: (input) statement node pointer */ 1 21 /* parameter 3: (input) tree pointer */ 1 22 /* parameter 4: (input) subscript pointer */ 1 23 /* parameter 5: (input) builtin symbol node pointer */ 1 24 /* parameter 6: (in/out) context */ 1 25 /* return: (output) tree pointer */ 1 26 1 27 declare check_star_extents entry(pointer,pointer); 1 28 /* parameter 1: (input) symbol node of procedure */ 1 29 /* parameter 2: (input) argument list pointer */ 1 30 1 31 declare compare_declaration entry(pointer,pointer,bit(1) aligned) reducible 1 32 returns(bit(1) aligned); 1 33 /* parameter 1: (input) reference or symbol node ptr */ 1 34 /* parameter 2: (input) symbol node ptr */ 1 35 /* parameter 3: (input) "1"b if aligned attribute ignored for string */ 1 36 /* return: (output) compare bit */ 1 37 1 38 declare context_processor entry(pointer,label); 1 39 /* parameter 1: (input) root block node pointer */ 1 40 1 41 declare declare entry(pointer); 1 42 /* parameter 1: (input) symbol node pointer */ 1 43 1 44 declare declare_structure entry(pointer); 1 45 /* parameter 1: (input) symbol node pointer */ 1 46 1 47 declare defined_reference entry(pointer,pointer,pointer,pointer,pointer,bit(36) aligned) 1 48 returns(pointer); 1 49 /* parameter 1: (input) block node pointer */ 1 50 /* parameter 2: (input) statement node pointer */ 1 51 /* parameter 3: (input) tree pointer */ 1 52 /* parameter 4: (input) subscript list pointer or null*/ 1 53 /* parameter 5: (input) symbol node pointer */ 1 54 /* parameter 6: (in/out) context */ 1 55 /* return: (output) tree pointer */ 1 56 1 57 declare do_semantics entry(pointer,pointer,pointer); 1 58 /* parameter 1: (input) block node pointer */ 1 59 /* parameter 2: (input) statement node pointer */ 1 60 /* parameter 3: (input) tree pointer */ 1 61 1 62 declare expand_assign entry(pointer,pointer,pointer,bit(36) aligned,pointer) 1 63 returns(pointer); 1 64 /* parameter 1: (input) block node pointer */ 1 65 /* parameter 2: (input) statement node pointer */ 1 66 /* parameter 3: (input) tree pointer */ 1 67 /* parameter 4: (in/out) context */ 1 68 /* parameter 5: (input) aggregate reference node ptr */ 1 69 /* return: (output) tree pointer */ 1 70 1 71 declare expand_by_name entry(pointer,pointer,pointer); 1 72 /* parameter 1: (input) block node pointer */ 1 73 /* parameter 2: (input) statement node pointer */ 1 74 /* parameter 3: (input/output) tree pointer */ 1 75 1 76 declare expand_infix entry(pointer,pointer,pointer,bit(36) aligned) 1 77 returns(pointer); 1 78 /* parameter 1: (input) block node pointer */ 1 79 /* parameter 2: (input) statement node pointer */ 1 80 /* parameter 3: (input) tree pointer */ 1 81 /* parameter 4: (in/out) context */ 1 82 /* return: (output) tree pointer */ 1 83 1 84 declare expand_initial entry(pointer,pointer,pointer); 1 85 /* parameter 1: (input) symbol node pointer */ 1 86 /* parameter 2: (input) statement node pointer */ 1 87 /* parameter 3: (input) locator */ 1 88 1 89 declare expand_prefix entry(pointer,pointer,pointer,bit(36) aligned) 1 90 returns(pointer); 1 91 /* parameter 1: (input) block node pointer */ 1 92 /* parameter 2: (input) statement node pointer */ 1 93 /* parameter 3: (input) tree pointer */ 1 94 /* parameter 4: (in/out) context */ 1 95 /* return: (output) tree pointer */ 1 96 1 97 declare expand_primitive entry(pointer,pointer,pointer,bit(36) aligned) 1 98 returns(pointer); 1 99 /* parameter 1: (input) block node pointer */ 1 100 /* parameter 2: (input) statement node pointer */ 1 101 /* parameter 3: (input) tree pointer */ 1 102 /* parameter 4: (input) context */ 1 103 /* return: (output) tree pointer */ 1 104 1 105 declare expression_semantics entry(pointer,pointer,pointer,bit(36) aligned) 1 106 returns(pointer); 1 107 /* parameter 1: (input) block node pointer */ 1 108 /* parameter 2: (input) statement node pointer */ 1 109 /* parameter 3: (input) tree pointer */ 1 110 /* parameter 4: (in/out) context */ 1 111 /* return: (output) tree pointer */ 1 112 1 113 declare fill_refer entry(pointer,pointer,bit(1) aligned) 1 114 returns(pointer); 1 115 /* parameter 1: (input) null,ref node,op node ptr */ 1 116 /* parameter 2: (input) null,ref node,op node ptr */ 1 117 /* parameter 3: (input) copy switch for param 2 */ 1 118 /* return: (output) ptr to processed tree */ 1 119 1 120 declare io_data_list_semantics$format_list_semantics entry(pointer,pointer,pointer); 1 121 /* parameter 1: (input) block node pointer */ 1 122 /* parameter 2: (input) statement node pointer */ 1 123 /* parameter 3: (in/out) tree pointer */ 1 124 1 125 declare function entry(pointer,pointer,pointer,pointer,bit(36) aligned) 1 126 returns(pointer); 1 127 /* parameter 1: (input) block node pointer */ 1 128 /* parameter 2: (input) statement node pointer */ 1 129 /* parameter 3: (input) tree pointer */ 1 130 /* parameter 4: (input) symbol node pointer */ 1 131 /* parameter 5: (in/out) context */ 1 132 /* return: (output) tree pointer */ 1 133 1 134 declare generic_selector entry(pointer,pointer,pointer,pointer,bit(36) aligned) 1 135 returns(pointer); 1 136 /* parameter 1: (input) block node pointer */ 1 137 /* parameter 2: (input) statement node pointer */ 1 138 /* parameter 3: (input) tree pointer */ 1 139 /* parameter 4: (input) pointer to argument list */ 1 140 /* parameter 5: (in/out) context */ 1 141 /* return: (output) tree pointer */ 1 142 1 143 declare io_data_list_semantics entry(pointer,pointer,pointer); 1 144 /* parameter 1: (input) block node pointer */ 1 145 /* parameter 2: (input) statement node pointer */ 1 146 /* parameter 3: (input) operator node pointer */ 1 147 1 148 declare io_semantics entry(pointer,pointer,pointer); 1 149 /* parameter 1: (input) block node pointer */ 1 150 /* parameter 2: (input) statement node pointer */ 1 151 /* parameter 3: (input) tree pointer */ 1 152 1 153 declare lookup entry(pointer,pointer,pointer,pointer,bit(36) aligned) 1 154 returns(bit(1) aligned); 1 155 /* parameter 1: (input) block node pointer */ 1 156 /* parameter 2: (input) stmnt|symbol node pointer */ 1 157 /* parameter 3: (input) token or reference node ptr */ 1 158 /* parameter 4: (output) symbol node pointer */ 1 159 /* parameter 5: (in/out) context */ 1 160 /* return: (output) symbol found bit */ 1 161 1 162 declare make_non_quick entry(pointer, bit (36) aligned); 1 163 /* parameter 1: (input) tree pointer */ 1 164 /* parameter 2: (input) reason why being made nonquick */ 1 165 1 166 declare match_arguments entry(pointer,pointer) reducible 1 167 returns(bit(1) aligned); 1 168 /* parameter 1: (input) reference or symbol node ptr */ 1 169 /* parameter 2: (input) reference or symbol node ptr */ 1 170 /* return: (output) compare bit */ 1 171 1 172 declare offset_adder entry(pointer,fixed binary(31),fixed binary(3),bit(1) aligned, 1 173 pointer,fixed binary(31),fixed binary(3),bit(1) aligned,bit(1)); 1 174 /* parameter 1: (in/out) tree pointer */ 1 175 /* parameter 2: (in/out) constant size */ 1 176 /* parameter 3: (in/out) units */ 1 177 /* parameter 4: (in/out) ON if units ^= word_, but tree in words */ 1 178 /* parameter 5: (input) tree pointer */ 1 179 /* parameter 6: (input) constant size */ 1 180 /* parameter 7: (input) units */ 1 181 /* parameter 8: (input) ON if units ^= word_, but tree in words */ 1 182 /* parameter 9: (input) ON if should not improve units */ 1 183 1 184 declare operator_semantics entry(pointer,pointer,pointer,bit(36) aligned) 1 185 returns(pointer); 1 186 /* parameter 1: (input) block node pointer */ 1 187 /* parameter 2: (input) statement node pointer */ 1 188 /* parameter 3: (input) tree pointer */ 1 189 /* parameter 4: (in/out) context */ 1 190 /* return: (output) tree pointer */ 1 191 1 192 declare propagate_bit entry(pointer,fixed binary(15)); 1 193 /* parameter 1: (input) symbol node pointer */ 1 194 /* parameter 2: (input) attribute number */ 1 195 1 196 declare semantic_translator$call_es entry(pointer,pointer,pointer,label,bit(1) aligned) 1 197 returns(pointer); 1 198 /* parameter 1: (input) block ptr */ 1 199 /* parameter 2: (input) statement ptr */ 1 200 /* parameter 3: (input) tree ptr */ 1 201 /* parameter 4: (input) failure label */ 1 202 /* parameter 5: (input) "1"b -- convert to integer */ 1 203 /* return: (output) tree ptr */ 1 204 1 205 declare simplify_expression entry(pointer,fixed bin,bit(1)aligned); 1 206 /* parameter 1: (in/out) tree pointer */ 1 207 /* parameter 2: (output) value of constant, if the entire tree 1 208* is simplified */ 1 209 /* parameter 3: (output) bit indicating if the tree has 1 210* been simplified */ 1 211 1 212 declare simplify_offset entry(pointer,bit(36) aligned); 1 213 /* parameter 1: (input) reference node pointer */ 1 214 /* parameter 2: (input) context */ 1 215 1 216 declare subscripter entry(pointer,pointer,pointer,pointer,pointer) 1 217 returns(pointer); 1 218 /* parameter 1: (input) block node pointer */ 1 219 /* parameter 2: (input) statement node pointer */ 1 220 /* parameter 3: (input) tree pointer */ 1 221 /* parameter 4: (in/out) subscript list pointer */ 1 222 /* parameter 5: (input) symbol node pointer */ 1 223 /* return: (output) reference node pointer */ 1 224 1 225 declare validate entry(pointer); 1 226 /* parameter 1: (input) symbol node pointer */ 1 227 2 1 /****^ ********************************************************* 2 2* * * 2 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 2 4* * * 2 5* ********************************************************* */ 2 6 2 7 /* BEGIN INCLUDE FILE ... language_utility.incl.pl1 */ 2 8 2 9 2 10 /****^ HISTORY COMMENTS: 2 11* 1) change(89-07-10,RWaters), approve(89-07-10,MCR8118), audit(89-07-19,Vu), 2 12* install(89-07-31,MR12.3-1066): 2 13* Removed the obsolete parameter source_line from the dcl of error_(). 2 14* END HISTORY COMMENTS */ 2 15 2 16 /* Modified: 6 Jun 1979 by PG to add rank and byte 2 17* * Modified: 9 Jul 1989 by RW updated the declaration of error_ 2 18* */ 2 19 2 20 declare adjust_count entry(pointer); 2 21 /* parameter 1: (input) any node pointer */ 2 22 2 23 declare bindec entry(fixed bin(31)) reducible 2 24 returns(character(12) aligned); 2 25 /* parameter 1: (input) bin value */ 2 26 /* return: (output) character value with blanks */ 2 27 2 28 declare bindec$vs entry(fixed bin(31)) reducible 2 29 returns(character(12) aligned varying); 2 30 /* parameter 1: (input) binary value */ 2 31 /* return: (output) char value without blanks */ 2 32 2 33 declare binoct entry(fixed bin(31)) reducible 2 34 returns(char(12) aligned); 2 35 /* parameter 1: (input) binary value */ 2 36 /* return: (output) char value with blanks */ 2 37 2 38 declare binary_to_octal_string entry(fixed bin(31)) reducible 2 39 returns(char(12) aligned); 2 40 /* parameter 1: (input) binary value */ 2 41 /* return: (output) right-aligned char value */ 2 42 2 43 declare binary_to_octal_var_string entry(fixed bin(31)) reducible 2 44 returns(char(12) varying aligned); 2 45 /* parameter 1: (input) binary value */ 2 46 /* returns: (output) char value without blanks */ 2 47 2 48 declare compare_expression entry(pointer,pointer) reducible 2 49 returns(bit(1) aligned); 2 50 /* parameter 1: (input) any node pointer */ 2 51 /* parameter 2: (input) any node pointer */ 2 52 /* return: (output) compare bit */ 2 53 2 54 declare constant_length entry (pointer, fixed bin (71)) 2 55 returns (bit (1) aligned); 2 56 /* parameter 1: (input) reference node pointer */ 2 57 /* parameter 2: (input) value of constant length */ 2 58 /* return: (output) "1"b if constant length */ 2 59 2 60 declare convert entry(pointer,bit(36) aligned) 2 61 returns(pointer); 2 62 /* parameter 1: (input) any node pointer */ 2 63 /* parameter 2: (input) target type */ 2 64 /* return: (output) target value tree pointer */ 2 65 2 66 declare convert$to_integer entry(pointer,bit(36)aligned) 2 67 returns(pointer); 2 68 /* parameter 1: (input) any node pointer */ 2 69 /* parameter 2: (input) target type */ 2 70 /* return: (output) target value tree pointer */ 2 71 2 72 declare convert$from_builtin entry(pointer,bit(36) aligned) 2 73 returns(pointer); 2 74 /* parameter 1: (input) any node pointer */ 2 75 /* parameter 2: (input) target type */ 2 76 /* return: (output) target value tree pointer */ 2 77 2 78 declare convert$validate entry(pointer,pointer); 2 79 /* parameter 1: (input) source value tree pointer */ 2 80 /* parameter 2: (input) target reference node pointer */ 2 81 2 82 declare convert$to_target_fb entry(pointer,pointer) 2 83 returns(pointer); 2 84 /* parameter 1: (input) source value tree pointer */ 2 85 /* parameter 2: (input) target reference node pointer */ 2 86 /* return: (output) target value tree pointer */ 2 87 2 88 declare convert$to_target entry(pointer,pointer) 2 89 returns(pointer); 2 90 /* parameter 1: (input) source value tree pointer */ 2 91 /* parameter 2: (input) target reference node pointer */ 2 92 /* return: (output) target value tree pointer */ 2 93 2 94 declare copy_expression entry(pointer unaligned) 2 95 returns(pointer); 2 96 /* parameter 1: (input) any node pointer */ 2 97 /* return: (output) any node pointer */ 2 98 2 99 declare copy_expression$copy_sons entry(pointer,pointer); 2 100 /* parameter 1: (input) father symbol node pointer */ 2 101 /* parameter 2: (input) stepfather symbol node ptr */ 2 102 2 103 declare copy_unique_expression entry(pointer) 2 104 returns(pointer); 2 105 /* parameter 1: (input) any node pointer */ 2 106 /* return: (output) any node pointer */ 2 107 2 108 declare create_array entry() 2 109 returns(pointer); 2 110 /* return: (output) array node pointer */ 2 111 2 112 declare create_block entry(bit(9) aligned,pointer) 2 113 returns(pointer); 2 114 /* parameter 1: (input) block type */ 2 115 /* parameter 2: (input) father block node pointer */ 2 116 /* return: (output) block node pointer */ 2 117 2 118 declare create_bound entry() 2 119 returns(pointer); 2 120 /* return: (output) bound node pointer */ 2 121 2 122 declare create_context entry(pointer,pointer) 2 123 returns(pointer); 2 124 /* parameter 1: (input) block node pointer */ 2 125 /* parameter 2: (input) token pointer */ 2 126 /* return: (output) context node pointer */ 2 127 2 128 declare create_cross_reference entry() 2 129 returns(pointer); 2 130 /* return: (output) cross reference node pointer */ 2 131 2 132 declare create_default entry 2 133 returns(pointer); 2 134 /* return: (output) default node pointer */ 2 135 2 136 declare create_identifier entry() 2 137 returns(pointer); 2 138 /* return: (output) token node pointer */ 2 139 2 140 declare create_label entry(pointer,pointer,bit(3) aligned) 2 141 returns(pointer); 2 142 /* parameter 1: (input) block node pointer */ 2 143 /* parameter 2: (input) token node pointer */ 2 144 /* parameter 3: (input) declare type */ 2 145 /* return: (output) label node pointer */ 2 146 2 147 declare create_list entry(fixed bin(15)) 2 148 returns(pointer); 2 149 /* parameter 1: (input) number of list elements */ 2 150 /* return: (output) list node pointer */ 2 151 2 152 declare create_operator entry(bit(9) aligned,fixed bin(15)) 2 153 returns(pointer); 2 154 /* parameter 1: (input) operator type */ 2 155 /* parameter 2: (input) number of operands */ 2 156 /* return: (output) operator node pointer */ 2 157 2 158 declare create_reference entry(pointer) 2 159 returns(pointer); 2 160 /* parameter 1: (input) symbol node pointer */ 2 161 /* return: (output) reference node pointer */ 2 162 2 163 declare create_statement entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 2 164 returns(pointer); 2 165 /* parameter 1: (input) statement type */ 2 166 /* parameter 2: (input) block node pointer */ 2 167 /* parameter 3: (input) label node pointer */ 2 168 /* parameter 4: (input) conditions */ 2 169 /* return: (output) statement node pointer */ 2 170 2 171 declare create_statement$prologue entry(bit(9) aligned,pointer,pointer,bit(12) aligned) 2 172 returns(pointer); 2 173 /* parameter 1: (input) statement type */ 2 174 /* parameter 2: (input) block node pointer */ 2 175 /* parameter 3: (input) label node pointer */ 2 176 /* parameter 4: (input) conditions */ 2 177 /* return: (output) statement node pointer */ 2 178 2 179 declare create_storage entry(fixed bin(15)) 2 180 returns(pointer); 2 181 /* parameter 1: (input) number of words */ 2 182 /* return: (output) storage block pointer */ 2 183 2 184 declare create_symbol entry(pointer,pointer,bit(3) aligned) 2 185 returns(pointer); 2 186 /* parameter 1: (input) block node pointer */ 2 187 /* parameter 2: (input) token node pointer */ 2 188 /* parameter 3: (input) declare type */ 2 189 /* return: (output) symbol node pointer */ 2 190 2 191 declare create_token entry (character (*), bit (9) aligned) 2 192 returns (ptr); 2 193 /* parameter 1: (input) token string */ 2 194 /* parameter 2: (input) token type */ 2 195 /* return: (output) token node ptr */ 2 196 2 197 declare create_token$init_hash_table entry (); 2 198 2 199 declare create_token$protected entry (char (*), bit (9) aligned, bit (18) aligned) 2 200 returns (ptr); 2 201 /* parameter 1: (input) token string */ 2 202 /* parameter 2: (input) token type */ 2 203 /* parameter 3: (input) protected flag */ 2 204 /* return: (output) token node ptr */ 2 205 2 206 declare decbin entry(character(*) aligned) reducible 2 207 returns(fixed bin(31)); 2 208 /* parameter 1: (input) decimal character string */ 2 209 /* return: (output) binary value */ 2 210 2 211 declare declare_constant entry(bit(*) aligned,bit(36) aligned,fixed bin(31),fixed bin(15)) 2 212 returns(pointer); 2 213 /* parameter 1: (input) value */ 2 214 /* parameter 2: (input) type */ 2 215 /* parameter 3: (input) size */ 2 216 /* parameter 4: (input) scale */ 2 217 /* return: (output) reference node pointer */ 2 218 2 219 declare declare_constant$bit entry(bit(*) aligned) 2 220 returns(pointer); 2 221 /* parameter 1: (input) bit */ 2 222 /* return: (output) reference node pointer */ 2 223 2 224 declare declare_constant$char entry(character(*) aligned) 2 225 returns(pointer); 2 226 /* parameter 1: (input) character */ 2 227 /* return: (output) reference node pointer */ 2 228 2 229 declare declare_constant$desc entry(bit(*) aligned) 2 230 returns(pointer); 2 231 /* parameter 1: (input) descriptor bit value */ 2 232 /* return: (output) reference node pointer */ 2 233 2 234 declare declare_constant$integer entry(fixed bin(31)) /* note...should really be fixed bin(24) */ 2 235 returns(pointer); 2 236 /* parameter 1: (input) integer */ 2 237 /* return: (output) reference node pointer */ 2 238 2 239 declare declare_descriptor entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 240 returns(pointer); 2 241 /* parameter 1: (input) block node pointer */ 2 242 /* parameter 2: (input) statement node pointer */ 2 243 /* parameter 3: (input) symbol node pointer */ 2 244 /* parameter 4: (input) loc pointer */ 2 245 /* parameter 5: (input) array descriptor bit 2 246* cross_section bit */ 2 247 /* return: (output) reference node pointer */ 2 248 2 249 declare declare_descriptor$ctl entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 250 returns(pointer); 2 251 /* parameter 1: (input) block node pointer */ 2 252 /* parameter 2: (input) statement node pointer */ 2 253 /* parameter 3: (input) symbol node pointer */ 2 254 /* parameter 4: (input) loc pointer */ 2 255 /* parameter 5: (input) array descriptor bit 2 256* cross_section bit */ 2 257 /* return: (output) reference node pointer */ 2 258 2 259 declare declare_descriptor$param entry(pointer,pointer,pointer,pointer,bit(2) aligned) 2 260 returns(pointer); 2 261 /* parameter 1: (input) block node pointer */ 2 262 /* parameter 2: (input) statement node pointer */ 2 263 /* parameter 3: (input) symbol node pointer */ 2 264 /* parameter 4: (input) loc pointer */ 2 265 /* parameter 5: (input) array descriptor bit 2 266* cross_section bit */ 2 267 /* return: (output) reference node pointer */ 2 268 2 269 declare declare_integer entry(pointer) 2 270 returns(pointer); 2 271 /* parameter 1: (input) block node pointer */ 2 272 /* return: (output) reference node pointer */ 2 273 2 274 declare declare_picture entry(char(*)aligned,pointer,fixed bin(15)); 2 275 /* parameter 1: (input) picture string */ 2 276 /* parameter 2: (input) symbol node pointer */ 2 277 /* parameter 3: (output) error code, if any */ 2 278 2 279 declare declare_picture_temp entry(char(*) aligned,fixed bin(31),bit(1) aligned,bit(1) aligned) 2 280 returns(pointer); 2 281 /* parameter 1: (input) picture string */ 2 282 /* parameter 2: (input) scalefactor of picture */ 2 283 /* parameter 3: (input) ="1"b => complex picture */ 2 284 /* parameter 4: (input) ="1"b => unaligned temp */ 2 285 /* return: (output) reference node pointer */ 2 286 2 287 declare declare_pointer entry(pointer) 2 288 returns(pointer); 2 289 /* parameter 1: (input) block node pointer */ 2 290 /* return: (output) reference node pointer */ 2 291 2 292 declare declare_temporary entry(bit(36) aligned,fixed bin(31),fixed bin(15),pointer) 2 293 returns(pointer); 2 294 /* parameter 1: (input) type */ 2 295 /* parameter 2: (input) precision */ 2 296 /* parameter 3: (input) scale */ 2 297 /* parameter 4: (input) length */ 2 298 /* return: (output) reference node pointer */ 2 299 2 300 declare decode_node_id entry(pointer,bit(1) aligned) 2 301 returns(char(120) varying); 2 302 /* parameter 1: (input) node pointer */ 2 303 /* parameter 2: (input) ="1"b => capitals */ 2 304 /* return: (output) source line id */ 2 305 2 306 declare decode_source_id entry( 3 1 1 structure unaligned, 3 2 2 /* file_number */ bit(8), 3 3 2 /* line_number */ bit(14), 3 4 2 /* stmt_number */ bit(5), 2 307 2 308 bit(1) aligned) 2 309 returns(char(120) varying); 2 310 /* parameter 1: (input) source id */ 2 311 /* parameter 2: (input) ="1"b => capitals */ 2 312 /* return: (output) source line id */ 2 313 2 314 declare error entry(fixed bin(15),pointer,pointer); 2 315 /* parameter 1: (input) error number */ 2 316 /* parameter 2: (input) statement node pointer or null*/ 2 317 /* parameter 3: (input) token node pointer */ 2 318 2 319 declare error$omit_text entry(fixed bin(15),pointer,pointer); 2 320 /* parameter 1: (input) error number */ 2 321 /* parameter 2: (input) statement node pointer or null*/ 2 322 /* parameter 3: (input) token node pointer */ 2 323 2 324 declare error_ entry(fixed bin(15), 4 1 1 structure unaligned, 4 2 2 /* file_number */ bit(8), 4 3 2 /* line_number */ bit(14), 4 4 2 /* stmt_number */ bit(5), 2 325 2 326 pointer,fixed bin(8),fixed bin(23),fixed bin(11)); 2 327 /* parameter 1: (input) error number */ 2 328 /* parameter 2: (input) statement id */ 2 329 /* parameter 3: (input) any node pointer */ 2 330 /* parameter 4: (input) source segment */ 2 331 /* parameter 5: (input) source starting character */ 2 332 /* parameter 6: (input) source length */ 2 333 2 334 declare error_$no_text entry(fixed bin(15), 5 1 1 structure unaligned, 5 2 2 /* file_number */ bit(8), 5 3 2 /* line_number */ bit(14), 5 4 2 /* stmt_number */ bit(5), 2 335 2 336 pointer); 2 337 /* parameter 1: (input) error number */ 2 338 /* parameter 2: (input) statement id */ 2 339 /* parameter 3: (input) any node pointer */ 2 340 2 341 declare error_$initialize_error entry(); 2 342 2 343 declare error_$finish entry(); 2 344 2 345 declare free_node entry(pointer); 2 346 /* parameter 1: any node pointer */ 2 347 2 348 declare get_array_size entry(pointer,fixed bin(3)); 2 349 /* parameter 1: (input) symbol node pointer */ 2 350 /* parameter 2: (input) units */ 2 351 2 352 declare get_size entry(pointer); 2 353 /* parameter 1: (input) symbol node pointer */ 2 354 2 355 declare merge_attributes external entry(pointer,pointer) 2 356 returns(bit(1) aligned); 2 357 /* parameter 1: (input) target symbol node pointer */ 2 358 /* parameter 2: (input) source symbol node pointer */ 2 359 /* return: (output) "1"b if merge was unsuccessful */ 2 360 2 361 declare optimizer entry(pointer); 2 362 /* parameter 1: (input) root pointer */ 2 363 2 364 declare parse_error entry(fixed bin(15),pointer); 2 365 /* parameter 1: (input) error number */ 2 366 /* parameter 2: (input) any node pointer */ 2 367 2 368 declare parse_error$no_text entry(fixed bin(15),pointer); 2 369 /* parameter 1: (input) error number */ 2 370 /* parameter 2: (input) any node pointer */ 2 371 2 372 declare pl1_error_print$write_out 2 373 entry(fixed bin(15), 6 1 1 structure unaligned, 6 2 2 /* file_number */ bit(8), 6 3 2 /* line_number */ bit(14), 6 4 2 /* stmt_number */ bit(5), 2 374 2 375 pointer,fixed bin(11),fixed bin(31),fixed bin(31),fixed bin(15)); 2 376 /* parameter 1: (input) error number */ 2 377 /* parameter 2: (input) statement identification */ 2 378 /* parameter 3: (input) any node pointer */ 2 379 /* parameter 4: (input) source segment */ 2 380 /* parameter 5: (input) source character index */ 2 381 /* parameter 6: (input) source length */ 2 382 /* parameter 7: (input) source line */ 2 383 2 384 declare pl1_error_print$listing_segment 2 385 entry(fixed bin(15), 7 1 1 structure unaligned, 7 2 2 /* file_number */ bit(8), 7 3 2 /* line_number */ bit(14), 7 4 2 /* stmt_number */ bit(5), 2 386 2 387 pointer); 2 388 /* parameter 1: (input) error number */ 2 389 /* parameter 2: (input) statement identification */ 2 390 /* parameter 3: (input) token node pointer */ 2 391 2 392 declare pl1_print$varying entry(character(*) aligned varying); 2 393 /* parameter 1: (input) string */ 2 394 2 395 declare pl1_print$varying_nl entry(character(*) aligned varying); 2 396 /* parameter 1: (input) string */ 2 397 2 398 declare pl1_print$non_varying entry(character(*) aligned,fixed bin(31)); 2 399 /* parameter 1: (input) string */ 2 400 /* parameter 2: (input) string length or 0 */ 2 401 2 402 declare pl1_print$non_varying_nl entry(character(*) aligned,fixed bin(31)); 2 403 /* parameter 1: (input) string */ 2 404 /* parameter 2: (input) string length or 0 */ 2 405 2 406 declare pl1_print$string_pointer entry(pointer,fixed bin(31)); 2 407 /* parameter 1: (input) string pointer */ 2 408 /* parameter 2: (input) string size */ 2 409 2 410 declare pl1_print$string_pointer_nl entry(pointer,fixed bin(31)); 2 411 /* parameter 1: (input) string pointer */ 2 412 /* parameter 2: (input) string length or 0 */ 2 413 2 414 declare pl1_print$unaligned_nl entry(character(*) unaligned,fixed bin(31)); 2 415 /* parameter 1: (input) string */ 2 416 /* parameter 2: (input) length */ 2 417 2 418 declare pl1_print$for_lex entry (ptr, fixed bin (14), fixed bin (21), fixed bin (21), bit (1) aligned, bit (1) aligned); 2 419 /* parameter 1: (input) ptr to base of source segment */ 2 420 /* parameter 2: (input) line number */ 2 421 /* parameter 3: (input) starting offset in source seg */ 2 422 /* parameter 4: (input) number of chars to copy */ 2 423 /* parameter 5: (input) ON iff shd print line number */ 2 424 /* parameter 6: (input) ON iff line begins in comment */ 2 425 2 426 declare refer_extent entry(pointer,pointer); 2 427 /* parameter 1: (input/output) null,ref node,op node pointer */ 2 428 /* parameter 2: (input) null,ref node,op node pointer */ 2 429 2 430 declare reserve$clear entry() 2 431 returns(pointer); 2 432 /* return: (output) pointer */ 2 433 2 434 declare reserve$declare_lib entry(fixed bin(15)) 2 435 returns(pointer); 2 436 /* parameter 1: (input) builtin function number */ 2 437 /* return: (output) pointer */ 2 438 2 439 declare reserve$read_lib entry(fixed bin(15)) 2 440 returns(pointer); 2 441 /* parameter 1: (input) builtin function number */ 2 442 /* return: (output) pointer */ 2 443 2 444 declare semantic_translator entry(); 2 445 2 446 declare semantic_translator$abort entry(fixed bin(15),pointer); 2 447 /* parameter 1: (input) error number */ 2 448 /* parameter 2: (input) any node pointer */ 2 449 2 450 declare semantic_translator$error entry(fixed bin(15),pointer); 2 451 /* parameter 1: (input) error number */ 2 452 /* parameter 2: (input) any node pointer */ 2 453 2 454 declare share_expression entry(ptr) 2 455 returns(ptr); 2 456 /* parameter 1: (input) usually operator node pointer */ 2 457 /* return: (output) tree pointer or null */ 2 458 2 459 declare token_to_binary entry(ptr) reducible 2 460 returns(fixed bin(31)); 2 461 /* parameter 1: (input) token node pointer */ 2 462 /* return: (output) converted binary value */ 2 463 2 464 /* END INCLUDE FILE ... language_utility.incl.pl1 */ 1 228 1 229 /* END INCLUDE FILE ... semant.incl.pl1 */ 1066 8 1 /* BEGIN INCLUDE FILE ... picture_image.incl.pl1 8 2* 8 3* James R. Davis 12 Mar 79 8 4**/ 8 5 8 6 dcl 1 picture_image aligned based, 8 7 2 type fixed bin (8) unal, 8 8 2 prec fixed bin (8) unal, /* precision or length of associated value */ 8 9 2 scale fixed bin (8) unal, /* for both fixed and float pictures, 8 10* =ndigits after "v" - scale_factor */ 8 11 2 piclength fixed bin (8) unal, /* length of picture_constant.chars, <64 8 12* =length of normalized-picture-string */ 8 13 2 varlength fixed bin (8) unal, /* length of pictured variable in chars, <64 8 14* =length of normalized_picture_string - "k" and "v" */ 8 15 2 scalefactor fixed bin (8) unal, /* value of pict-sc-f, -256<=x<256 */ 8 16 2 explength fixed bin (8) unal, /* length of exp field for float */ 8 17 2 drift_character char (1) unal, 8 18 2 chars char (0 refer (picture_image.piclength)) aligned; 8 19 8 20 dcl ( 8 21 picture_char_type init (24), 8 22 picture_realfix_type init (25), 8 23 picture_complexfix_type 8 24 init (26), 8 25 picture_realflo_type init (27), 8 26 picture_complexflo_type 8 27 init (28) 8 28 ) fixed bin (8) unal static internal options (constant); 8 29 8 30 /* END INCLUDE FILE ... picture_image.incl.pl1 */ 1067 9 1 /* BEGIN INCLUDE FILE ... nodes.incl.pl1 */ 9 2 9 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 9 4 9 5 dcl ( block_node initial("000000001"b), 9 6 statement_node initial("000000010"b), 9 7 operator_node initial("000000011"b), 9 8 reference_node initial("000000100"b), 9 9 token_node initial("000000101"b), 9 10 symbol_node initial("000000110"b), 9 11 context_node initial("000000111"b), 9 12 array_node initial("000001000"b), 9 13 bound_node initial("000001001"b), 9 14 format_value_node initial("000001010"b), 9 15 list_node initial("000001011"b), 9 16 default_node initial("000001100"b), 9 17 machine_state_node initial("000001101"b), 9 18 source_node initial("000001110"b), 9 19 label_node initial("000001111"b), 9 20 cross_reference_node initial("000010000"b), 9 21 sf_par_node initial("000010001"b), 9 22 temporary_node initial("000010010"b), 9 23 label_array_element_node initial("000010011"b), 9 24 by_name_agg_node initial("000010100"b)) 9 25 bit(9) internal static aligned options(constant); 9 26 9 27 dcl 1 node based aligned, 9 28 2 type unal bit(9), 9 29 2 source_id unal structure, 9 30 3 file_number bit(8), 9 31 3 line_number bit(14), 9 32 3 statement_number bit(5); 9 33 9 34 /* END INCLUDE FILE ... nodes.incl.pl1 */ 1068 10 1 /* BEGIN INCLUDE FILE ... system.incl.pl1 */ 10 2 10 3 /* Modified: 25 Apr 1979 by PCK to implemnt 4-bit decimal */ 10 4 10 5 dcl ( max_p_flt_bin_1 initial(27), 10 6 max_p_flt_bin_2 initial(63), 10 7 max_p_fix_bin_1 initial(35), 10 8 max_p_fix_bin_2 initial(71), 10 9 10 10 max_p_dec initial(59), 10 11 max_p_bin_or_dec initial (71), /* max (max_p_fix_bin_2, max_p_dec) */ 10 12 10 13 min_scale initial(-128), 10 14 max_scale initial(+127), 10 15 max_bit_string initial(9437184), 10 16 max_char_string initial(1048576), 10 17 max_area_size initial(262144), 10 18 min_area_size initial(28), 10 19 10 20 max_bit_string_constant initial (253), /* max length of bit literals */ 10 21 max_char_string_constant initial (254), /* max length of character literals */ 10 22 max_identifier_length initial (256), 10 23 max_number_of_dimensions initial (127), 10 24 10 25 max_length_precision initial(24), 10 26 max_offset_precision initial(24), /* 18 bits for word offset + 6 bits for bit offset */ 10 27 10 28 max_words_per_variable initial (262144), 10 29 10 30 bits_per_word initial(36), 10 31 bits_per_double initial(72), 10 32 packed_digits_per_character initial(2), 10 33 characters_per_half initial(2), 10 34 characters_per_word initial(4), 10 35 characters_per_double initial(8), 10 36 10 37 bits_per_character initial(9), 10 38 bits_per_half initial(18), 10 39 bits_per_decimal_digit initial(9), 10 40 bits_per_binary_exponent initial(8), 10 41 bits_per_packed_ptr initial(36), 10 42 words_per_packed_pointer initial(1), 10 43 10 44 words_per_fix_bin_1 initial(1), 10 45 words_per_fix_bin_2 initial(2), 10 46 words_per_flt_bin_1 initial(1), 10 47 words_per_flt_bin_2 initial(2), 10 48 words_per_varying_string_header initial(1), 10 49 words_per_offset initial(1), 10 50 words_per_pointer initial(2), 10 51 words_per_label_var initial(4), 10 52 words_per_entry_var initial(4), 10 53 words_per_file_var initial(4), 10 54 words_per_format initial(4), 10 55 words_per_condition_var initial(6), 10 56 10 57 max_index_register_value initial(262143), 10 58 max_signed_index_register_value initial(131071), 10 59 10 60 max_signed_xreg_precision initial(17), 10 61 max_uns_xreg_precision initial(18), 10 62 10 63 default_area_size initial(1024), 10 64 default_flt_bin_p initial(27), 10 65 default_fix_bin_p initial(17), 10 66 default_flt_dec_p initial(10), 10 67 default_fix_dec_p initial(7)) fixed bin(31) internal static options(constant); 10 68 10 69 dcl bits_per_digit initial(4.5) fixed bin(31,1) internal static options(constant); 10 70 10 71 dcl ( integer_type initial("010000000000000000000100000001100000"b), 10 72 dec_integer_type initial("010000000000000000000100000010100000"b), 10 73 pointer_type initial("000001000000000000000100000000000000"b), 10 74 real_type initial("001000000000000000000100000001100000"b), 10 75 complex_type initial("001000000000000000000100000001010000"b), 10 76 builtin_type initial("000000000000000010000000000000000000"b), 10 77 storage_block_type initial("000000000000100000000000000000000000"b), 10 78 arg_desc_type initial("000000000001000000000000000000000000"b), 10 79 local_label_var_type initial("000000001000000000000100000100001000"b), 10 80 entry_var_type initial("000000000100000000000000000000001000"b), 10 81 bit_type initial("000100000000000000000000000000000000"b), 10 82 char_type initial("000010000000000000000000000000000000"b)) bit(36) aligned int static 10 83 options(constant); 10 84 10 85 /* END INCLUDE FILE ... system.incl.pl1 */ 1069 11 1 /* BEGIN INCLUDE FILE ... mask.incl.pl1 */ 11 2 11 3 dcl ( structure_mask init("100000000000000000000000000000000000"b), 11 4 fixed_mask init("010000000000000000000000000000000000"b), 11 5 float_mask init("001000000000000000000000000000000000"b), 11 6 bit_mask init("000100000000000000000000000000000000"b), 11 7 char_mask init("000010000000000000000000000000000000"b), 11 8 ptr_mask init("000001000000000000000000000000000000"b), 11 9 offset_mask init("000000100000000000000000000000000000"b), 11 10 area_mask init("000000010000000000000000000000000000"b), 11 11 label_mask init("000000001000000000000000000000000000"b), 11 12 entry_mask init("000000000100000000000000000000000000"b), 11 13 file_mask init("000000000010000000000000000000000000"b), 11 14 arg_descriptor_mask init("000000000001000000000000000000000000"b), 11 15 storage_block_mask init("000000000000100000000000000000000000"b), 11 16 lock_mask init("000000000000010000000000000000000000"b), 11 17 condition_mask init("000000000000001000000000000000000000"b), 11 18 format_mask init("000000000000000100000000000000000000"b), 11 19 builtin_mask init("000000000000000010000000000000000000"b), 11 20 generic_mask init("000000000000000001000000000000000000"b), 11 21 picture_mask init("000000000000000000100000000000000000"b), 11 22 dimensioned_mask init("000000000000000000010000000000000000"b), 11 23 initialed_mask init("000000000000000000001000000000000000"b), 11 24 aligned_mask init("000000000000000000000100000000000000"b), 11 25 unaligned_mask init("000000000000000000000010000000000000"b), 11 26 signed_mask init("000000000000000000000001000000000000"b), 11 27 unsigned_mask init("000000000000000000000000100000000000"b), 11 28 precision_mask init("000000000000000000000000010000000000"b), 11 29 varying_mask init("000000000000000000000000001000000000"b), 11 30 local_mask init("000000000000000000000000000100000000"b), 11 31 decimal_mask init("000000000000000000000000000010000000"b), 11 32 binary_mask init("000000000000000000000000000001000000"b), 11 33 real_mask init("000000000000000000000000000000100000"b), 11 34 complex_mask init("000000000000000000000000000000010000"b), 11 35 variable_mask init("000000000000000000000000000000001000"b), 11 36 reducible_mask init("000000000000000000000000000000000100"b), 11 37 irreducible_mask init("000000000000000000000000000000000010"b), 11 38 returns_mask init("000000000000000000000000000000000001"b)) bit(36) aligned int static 11 39 options(constant); 11 40 11 41 dcl ( arithmetic_mask init("011000000000000000000000000011110000"b), 11 42 computational_mask init("011110000000000000100000000011110000"b), 11 43 fixed_binary_real_mask init("010000000000000000000000000001100000"b), 11 44 fixed_decimal_real_mask init("010000000000000000000000000010100000"b), 11 45 float_decimal_real_mask init("001000000000000000000000000010100000"b), 11 46 fixed_decimal_complex_mask init("010000000000000000000000000010010000"b), 11 47 float_decimal_complex_mask init("001000000000000000000000000010010000"b), 11 48 string_mask init("000110000000000000000000000000000000"b), 11 49 undesirable_mask init("111111111111111111100111110111110111"b), 11 50 convert_mask init("011111111111111111100111110111111110"b), 11 51 declare_constant_mask init("111111111111111111100000000011110000"b) 11 52 ) bit(36) aligned int static 11 53 options(constant); 11 54 11 55 /* END INCLUDE FILE ... mask.incl.pl1 */ 1070 12 1 /* BEGIN INCLUDE FILE ... reference.incl.pl1 */ 12 2 12 3 dcl 1 reference based aligned, 12 4 2 node_type bit(9) unaligned, 12 5 2 array_ref bit(1) unaligned, 12 6 2 varying_ref bit(1) unaligned, 12 7 2 shared bit(1) unaligned, 12 8 2 put_data_sw bit(1) unaligned, 12 9 2 processed bit(1) unaligned, 12 10 2 units fixed(3) unaligned, 12 11 2 ref_count fixed(17) unaligned, 12 12 2 c_offset fixed(24), 12 13 2 c_length fixed(24), 12 14 2 symbol ptr unaligned, 12 15 2 qualifier ptr unaligned, 12 16 2 offset ptr unaligned, 12 17 2 length ptr unaligned, 12 18 2 subscript_list ptr unaligned, 12 19 /* these fields are used by the 645 code generator */ 12 20 2 address structure unaligned, 12 21 3 base bit(3), 12 22 3 offset bit(15), 12 23 3 op bit(9), 12 24 3 no_address bit(1), 12 25 3 inhibit bit(1), 12 26 3 ext_base bit(1), 12 27 3 tag bit(6), 12 28 2 info structure unaligned, 12 29 3 address_in structure, 12 30 4 b dimension(0:7) bit(1), 12 31 4 storage bit(1), 12 32 3 value_in structure, 12 33 4 a bit(1), 12 34 4 q bit(1), 12 35 4 aq bit(1), 12 36 4 string_aq bit(1), 12 37 4 complex_aq bit(1), 12 38 4 decimal_aq bit(1), 12 39 4 b dimension(0:7) bit(1), 12 40 4 storage bit(1), 12 41 4 indicators bit(1), 12 42 4 x dimension(0:7) bit(1), 12 43 3 other structure, 12 44 4 big_offset bit(1), 12 45 4 big_length bit(1), 12 46 4 modword_in_offset bit(1), 12 47 2 data_type fixed(5) unaligned, 12 48 2 bits structure unaligned, 12 49 3 padded_ref bit(1), 12 50 3 aligned_ref bit(1), 12 51 3 long_ref bit(1), 12 52 3 forward_ref bit(1), 12 53 3 ic_ref bit(1), 12 54 3 temp_ref bit(1), 12 55 3 defined_ref bit(1), 12 56 3 evaluated bit(1), 12 57 3 allocate bit(1), 12 58 3 allocated bit(1), 12 59 3 aliasable bit(1), 12 60 3 even bit(1), 12 61 3 perm_address bit(1), 12 62 3 aggregate bit(1), 12 63 3 hit_zero bit(1), 12 64 3 dont_save bit(1), 12 65 3 fo_in_qual bit(1), 12 66 3 hard_to_load bit(1), 12 67 2 relocation bit(12) unaligned, 12 68 2 more_bits structure unaligned, 12 69 3 substr bit(1), 12 70 3 padded_for_store_ref bit(1), 12 71 3 aligned_for_store_ref bit(1), 12 72 3 mbz bit(15), 12 73 2 store_ins bit(18) unaligned; 12 74 12 75 /* END INCLUDE FILE ... reference.incl.pl1 */ 1071 13 1 /* BEGIN INCLUDE FILE ... block.incl.pl1 */ 13 2 /* Modified 22 Ocober 1980 by M. N. Davidoff to increase max block.number to 511 */ 13 3 /* format: style3,idind30 */ 13 4 13 5 declare 1 block aligned based, 13 6 2 node_type bit (9) unaligned, 13 7 2 source_id structure unaligned, 13 8 3 file_number bit (8), 13 9 3 line_number bit (14), 13 10 3 statement_number bit (5), 13 11 2 father ptr unaligned, 13 12 2 brother ptr unaligned, 13 13 2 son ptr unaligned, 13 14 2 declaration ptr unaligned, 13 15 2 end_declaration ptr unaligned, 13 16 2 default ptr unaligned, 13 17 2 end_default ptr unaligned, 13 18 2 context ptr unaligned, 13 19 2 prologue ptr unaligned, 13 20 2 end_prologue ptr unaligned, 13 21 2 main ptr unaligned, 13 22 2 end_main ptr unaligned, 13 23 2 return_values ptr unaligned, 13 24 2 return_count ptr unaligned, 13 25 2 plio_ps ptr unaligned, 13 26 2 plio_fa ptr unaligned, 13 27 2 plio_ffsb ptr unaligned, 13 28 2 plio_ssl ptr unaligned, 13 29 2 plio_fab2 ptr unaligned, 13 30 2 block_type bit (9) unaligned, 13 31 2 prefix bit (12) unaligned, 13 32 2 like_attribute bit (1) unaligned, 13 33 2 no_stack bit (1) unaligned, 13 34 2 get_data bit (1) unaligned, 13 35 2 flush_at_call bit (1) unaligned, 13 36 2 processed bit (1) unaligned, 13 37 2 text_displayed bit (1) unaligned, 13 38 2 number fixed bin (9) unsigned unaligned, 13 39 2 free_temps dimension (3) ptr, /* these fields are used by the code generator */ 13 40 2 temp_list ptr, 13 41 2 entry_list ptr, 13 42 2 o_and_s ptr, 13 43 2 why_nonquick aligned, 13 44 3 auto_adjustable_storage bit (1) unaligned, 13 45 3 returns_star_extents bit (1) unaligned, 13 46 3 stack_extended_by_args bit (1) unaligned, 13 47 3 invoked_by_format bit (1) unaligned, 13 48 3 format_statement bit (1) unaligned, 13 49 3 io_statements bit (1) unaligned, 13 50 3 assigned_to_entry_var bit (1) unaligned, 13 51 3 condition_statements bit (1) unaligned, 13 52 3 no_owner bit (1) unaligned, 13 53 3 recursive_call bit (1) unaligned, 13 54 3 options_non_quick bit (1) unaligned, 13 55 3 options_variable bit (1) unaligned, 13 56 3 never_referenced bit (1) unaligned, 13 57 3 pad_nonquick bit (5) unaligned, 13 58 2 prologue_flag bit (1) unaligned, 13 59 2 options_main bit (1) unaligned, 13 60 2 pad bit (16) unaligned, 13 61 2 number_of_entries fixed bin (17), 13 62 2 level fixed bin (17), 13 63 2 last_auto_loc fixed bin (17), 13 64 2 symbol_block fixed bin (17), 13 65 2 entry_info fixed bin (18), 13 66 2 enter structure unaligned, 13 67 3 start fixed bin (17), 13 68 3 end fixed bin (17), 13 69 2 leave structure unaligned, 13 70 3 start fixed bin (17), 13 71 3 end fixed bin (17), 13 72 2 owner ptr; 13 73 13 74 declare max_block_number fixed bin internal static options (constant) initial (511); 13 75 13 76 /* END INCLUDE FILE ... block.incl.pl1 */ 1072 14 1 /* BEGIN INCLUDE FILE ... token.incl.pl1 */ 14 2 14 3 dcl 1 token based aligned, 14 4 2 node_type bit(9) unaligned, 14 5 2 type bit(9) unaligned, 14 6 2 loc bit(18) unaligned, /* symtab offset for identifiers, "p" flag for constants */ 14 7 2 declaration ptr unaligned, 14 8 2 next ptr unaligned, 14 9 2 size fixed(9), 14 10 2 string char(n refer(token.size)); 14 11 14 12 /* END INCLUDE FILE ... token.incl.pl1 */ 1073 15 1 /* BEGIN INCLUDE FILE ... token_types.incl.pl1 */ 15 2 15 3 dcl ( no_token initial("000000000"b), /* token types */ 15 4 identifier initial("100000000"b), 15 5 isub initial("010000000"b), 15 6 plus initial("001000001"b), 15 7 minus initial("001000010"b), 15 8 asterisk initial("001000011"b), 15 9 slash initial("001000100"b), 15 10 expon initial("001000101"b), 15 11 not initial("001000110"b), 15 12 and initial("001000111"b), 15 13 or initial("001001000"b), 15 14 cat initial("001001001"b), 15 15 eq initial("001001010"b), 15 16 ne initial("001001011"b), 15 17 lt initial("001001100"b), 15 18 gt initial("001001101"b), 15 19 le initial("001001110"b), 15 20 ge initial("001001111"b), 15 21 ngt initial("001010000"b), 15 22 nlt initial("001010001"b), 15 23 assignment initial("001010010"b), 15 24 colon initial("001010011"b), 15 25 semi_colon initial("001010100"b), 15 26 comma initial("001010101"b), 15 27 period initial("001010110"b), 15 28 arrow initial("001010111"b), 15 29 left_parn initial("001011000"b), 15 30 right_parn initial("001011001"b), 15 31 percent initial("001011100"b), 15 32 bit_string initial("000100001"b), 15 33 char_string initial("000100010"b), 15 34 bin_integer initial("000110001"b), 15 35 dec_integer initial("000110011"b), 15 36 fixed_bin initial("000110000"b), 15 37 fixed_dec initial("000110010"b), 15 38 float_bin initial("000110100"b), 15 39 float_dec initial("000110110"b), 15 40 i_bin_integer initial("000111001"b), 15 41 i_dec_integer initial("000111011"b), 15 42 i_fixed_bin initial("000111000"b), 15 43 i_fixed_dec initial("000111010"b), 15 44 i_float_bin initial("000111100"b), 15 45 i_float_dec initial("000111110"b)) bit (9) aligned internal static options (constant); 15 46 15 47 dcl ( is_identifier initial ("100000000"b), /* token type masks */ 15 48 is_isub initial ("010000000"b), 15 49 is_delimiter initial ("001000000"b), 15 50 is_constant initial ("000100000"b), 15 51 is_arith_constant initial ("000010000"b), /* N.B. not really a mask...s/b "000110000"b */ 15 52 is_arithmetic_constant initial ("000110000"b), 15 53 is_imaginary_constant initial ("000111000"b), 15 54 is_float_constant initial ("000110100"b), 15 55 is_decimal_constant initial ("000110010"b), 15 56 is_integral_constant initial ("000110001"b) 15 57 ) bit(9) internal static aligned options(constant); 15 58 15 59 /* END INCLUDE FILE ... token_types.incl.pl1 */ 1074 16 1 /* BEGIN INCLUDE FILE ... semantic_bits.incl.pl1 */ 16 2 16 3 /* Modified: 26 Dec 1979 by PCK to implement by name assignment */ 16 4 16 5 dcl context aligned bit(36), 16 6 this_context aligned bit(36); 16 7 16 8 dcl 1 def_context aligned based(addr(context)), 16 9 2 aggregate unaligned bit(1), 16 10 2 arg_list unaligned bit(1), 16 11 2 left_side unaligned bit(1), 16 12 2 return unaligned bit(1), 16 13 2 evaluate_offset unaligned bit(1), 16 14 2 top unaligned bit(1), 16 15 2 RHS_aggregate unaligned bit(1), 16 16 2 return_from_empty unaligned bit(1), 16 17 2 ignore_based unaligned bit(1), 16 18 2 ext_param unaligned bit(1), 16 19 2 cross_section unaligned bit(1), 16 20 2 string_unspec unaligned bit(1), 16 21 2 f_offset_to_be_added unaligned bit(1), 16 22 2 suppress_cross_ref unaligned bit(1), 16 23 2 by_name_assignment unaligned bit(1), 16 24 2 by_name_lookup unaligned bit(1), 16 25 2 pad unaligned bit(20); 16 26 16 27 dcl 1 def_this_context aligned like def_context based(addr(this_context)); 16 28 16 29 /* END INCLUDE FILE ... semantic_bits.incl.pl1 */ 1075 17 1 /* BEGIN INCLUDE FILE ... symbol.incl.pl1 */ 17 2 17 3 dcl 1 symbol based aligned, 17 4 2 node_type bit(9) unal, 17 5 2 source_id structure unal, 17 6 3 file_number bit(8), 17 7 3 line_number bit(14), 17 8 3 statement_number bit(5), 17 9 2 location fixed(18) unal unsigned, 17 10 2 allocated bit(1) unal, 17 11 2 dcl_type bit(3) unal, 17 12 2 reserved bit(6) unal, 17 13 2 pix unal, 17 14 3 pic_fixed bit(1) unal, 17 15 3 pic_float bit(1) unal, 17 16 3 pic_char bit(1) unal, 17 17 3 pic_scale fixed(7) unal, 17 18 3 pic_size fixed(7) unal, 17 19 2 level fixed(8) unal, 17 20 2 boundary fixed(3) unal, 17 21 2 size_units fixed(3) unal, 17 22 2 scale fixed(7) unal, 17 23 2 runtime bit(18) unal, 17 24 2 runtime_offset bit(18) unal, 17 25 2 block_node ptr unal, 17 26 2 token ptr unal, 17 27 2 next ptr unal, 17 28 2 multi_use ptr unal, 17 29 2 cross_references ptr unal, 17 30 2 initial ptr unal, 17 31 2 array ptr unal, 17 32 2 descriptor ptr unal, 17 33 2 equivalence ptr unal, 17 34 2 reference ptr unal, 17 35 2 general ptr unal, 17 36 2 father ptr unal, 17 37 2 brother ptr unal, 17 38 2 son ptr unal, 17 39 2 word_size ptr unal, 17 40 2 bit_size ptr unal, 17 41 2 dcl_size ptr unal, 17 42 2 symtab_size ptr unal, 17 43 2 c_word_size fixed(24), 17 44 2 c_bit_size fixed(24), 17 45 2 c_dcl_size fixed(24), 17 46 17 47 2 attributes structure aligned, 17 48 3 data_type structure unal, 17 49 4 structure bit(1) , 17 50 4 fixed bit(1), 17 51 4 float bit(1), 17 52 4 bit bit(1), 17 53 4 char bit(1), 17 54 4 ptr bit(1), 17 55 4 offset bit(1), 17 56 4 area bit(1), 17 57 4 label bit(1), 17 58 4 entry bit(1), 17 59 4 file bit(1), 17 60 4 arg_descriptor bit(1), 17 61 4 storage_block bit(1), 17 62 4 explicit_packed bit(1), /* options(packed) */ 17 63 4 condition bit(1), 17 64 4 format bit(1), 17 65 4 builtin bit(1), 17 66 4 generic bit(1), 17 67 4 picture bit(1), 17 68 17 69 3 misc_attributes structure unal, 17 70 4 dimensioned bit(1), 17 71 4 initialed bit(1), 17 72 4 aligned bit(1), 17 73 4 unaligned bit(1), 17 74 4 signed bit(1), 17 75 4 unsigned bit(1), 17 76 4 precision bit(1), 17 77 4 varying bit(1), 17 78 4 local bit(1), 17 79 4 decimal bit(1), 17 80 4 binary bit(1), 17 81 4 real bit(1), 17 82 4 complex bit(1), 17 83 4 variable bit(1), 17 84 4 reducible bit(1), 17 85 4 irreducible bit(1), 17 86 4 returns bit(1), 17 87 4 position bit(1), 17 88 4 internal bit(1), 17 89 4 external bit(1), 17 90 4 like bit(1), 17 91 4 member bit(1), 17 92 4 non_varying bit(1), 17 93 4 options bit(1), 17 94 4 variable_arg_list bit(1), /* options(variable) */ 17 95 4 alloc_in_text bit(1), /* options(constant) */ 17 96 17 97 3 storage_class structure unal, 17 98 4 auto bit(1), 17 99 4 based bit(1), 17 100 4 static bit(1), 17 101 4 controlled bit(1), 17 102 4 defined bit(1), 17 103 4 parameter bit(1), 17 104 4 param_desc bit(1), 17 105 4 constant bit(1), 17 106 4 temporary bit(1), 17 107 4 return_value bit(1), 17 108 17 109 3 file_attributes structure unal, 17 110 4 print bit(1), 17 111 4 input bit(1), 17 112 4 output bit(1), 17 113 4 update bit(1), 17 114 4 stream bit(1), 17 115 4 reserved_1 bit(1), 17 116 4 record bit(1), 17 117 4 sequential bit(1), 17 118 4 direct bit(1), 17 119 4 interactive bit(1), /* env(interactive) */ 17 120 4 reserved_2 bit(1), 17 121 4 reserved_3 bit(1), 17 122 4 stringvalue bit(1), /* env(stringvalue) */ 17 123 4 keyed bit(1), 17 124 4 reserved_4 bit(1), 17 125 4 environment bit(1), 17 126 17 127 3 compiler_developed structure unal, 17 128 4 aliasable bit(1), 17 129 4 packed bit(1), 17 130 4 passed_as_arg bit(1), 17 131 4 allocate bit(1), 17 132 4 set bit(1), 17 133 4 exp_extents bit(1), 17 134 4 refer_extents bit(1), 17 135 4 star_extents bit(1), 17 136 4 isub bit(1), 17 137 4 put_in_symtab bit(1), 17 138 4 contiguous bit(1), 17 139 4 put_data bit(1), 17 140 4 overlayed bit(1), 17 141 4 error bit(1), 17 142 4 symtab_processed bit(1), 17 143 4 overlayed_by_builtin bit(1), 17 144 4 defaulted bit(1), 17 145 4 connected bit(1); 17 146 17 147 /* END INCLUDE FILE ... symbol.incl.pl1 */ 1076 1077 1078 18 1 /* BEGIN INCLUDE FILE ... boundary.incl.pl1 */ 18 2 18 3 /* Modified: 26 Apr 1979 by PCK to implement 4-bit decimal */ 18 4 18 5 dcl ( bit_ init(1), 18 6 digit_ init(2), 18 7 character_ init(3), 18 8 half_ init(4), 18 9 word_ init(5), 18 10 mod2_ init(6), 18 11 mod4_ init(7)) fixed bin(3) int static options(constant); 18 12 18 13 /* END INCLUDE FILE ... boundary.incl.pl1 */ 1079 19 1 /* BEGIN INCLUDE FILE ... declare_type.incl.pl1 */ 19 2 19 3 /* Modified: 25 Apr 1979 by PCK to implement 4-bit decimal */ 19 4 19 5 dcl ( by_declare initial("001"b), 19 6 by_explicit_context initial("010"b), 19 7 by_context initial("011"b), 19 8 by_implication initial("100"b), 19 9 by_compiler initial("101"b)) int static bit(3) aligned options(constant); 19 10 19 11 /* END INCLUDE FILE ... declare_type.incl.pl1 */ 1080 20 1 dcl 1 label based aligned, 20 2 2 node_type bit(9) unaligned, 20 3 2 source_id structure unaligned, 20 4 3 file_number bit(8), 20 5 3 line_number bit(14), 20 6 3 statement_number bit(5), 20 7 2 location fixed(17) unaligned, 20 8 2 allocated bit(1) unaligned, 20 9 2 dcl_type bit(3) unaligned, 20 10 2 reserved bit(29) unaligned, 20 11 2 array bit(1) unaligned, 20 12 2 used_as_format bit(1) unaligned, 20 13 2 used_in_goto bit(1) unaligned, 20 14 2 symbol_table bit(18) unaligned, 20 15 2 low_bound fixed(17) unaligned, 20 16 2 high_bound fixed(17) unaligned, 20 17 2 block_node ptr unaligned, 20 18 2 token ptr unaligned, 20 19 2 next ptr unaligned, 20 20 2 multi_use ptr unaligned, 20 21 2 cross_reference ptr unaligned, 20 22 2 statement ptr unaligned; 1081 21 1 /* BEGIN INCLUDE FILE ... list.incl.pl1 */ 21 2 21 3 /* Modified 26 June 81 by EBush to add max_list_elements */ 21 4 21 5 21 6 dcl 1 list based aligned, 21 7 2 node_type bit(9) unaligned, 21 8 2 reserved bit(12) unaligned, 21 9 2 number fixed(14) unaligned, 21 10 2 element dimension(n refer(list.number)) ptr unaligned; 21 11 21 12 dcl max_list_elements fixed bin(17) internal static options (constant) 21 13 init(16383); 21 14 21 15 /* END INCLUDE FILE ... list.incl.pl1 */ 1082 22 1 /* BEGIN INCLUDE FILE ... op_codes.incl.pl1 */ 22 2 22 3 /* Modified: 25 Apr 1979 by PCK 4-bit decimal */ 22 4 /* Modified: 6 Jun 1979 by PG to add rank and byte */ 22 5 /* Modified: 26 Dec 1979 by PCK to add assign_by_name */ 22 6 /* Modified: 26 July 82 BIM wordno, segno */ 22 7 22 8 dcl ( add initial("000010001"b), /* opnd(1) <- opnd(2)+opnd(3) */ 22 9 sub initial("000010010"b), /* opnd(1) <- opnd(2)-opnd(3) */ 22 10 mult initial("000010011"b), /* opnd(1) <- opnd(2)*opnd(3) */ 22 11 div initial("000010100"b), /* opnd(1) <- opnd(2)/opnd(3) */ 22 12 negate initial("000010101"b), /* opnd(1) <- -opnd(2) */ 22 13 exp initial("000010110"b), /* opnd(1) <- opnd(2) ** opnd(3) */ 22 14 22 15 and_bits initial("000100001"b), /* opnd(1) <- opnd(2) & opnd(3) */ 22 16 or_bits initial("000100010"b), /* opnd(1) <- opnd(2)|opnd(3) */ 22 17 xor_bits initial("000100011"b), /* opnd(1) <- opnd(2) xor opnd(3) */ 22 18 not_bits initial("000100100"b), /* opnd(1) <- ^opnd(2) */ 22 19 cat_string initial("000100101"b), /* opnd(1) <- opnd(2)||opnd(3) */ 22 20 bool_fun initial("000100110"b), /* opnd(1) <- bool(opnd(2),opnd(3),opnd(4)) */ 22 21 22 22 assign initial("000110001"b), /* opnd(1) <- opnd(2) */ 22 23 assign_size_ck initial("000110010"b), /* opnd(1) <- opnd(2) */ 22 24 assign_zero initial("000110011"b), /* opnd(1) <- 0 */ 22 25 copy_words initial("000110100"b), /* move opnd(2) to opnd(1) by opnd(3) words */ 22 26 copy_string initial("000110101"b), /* move opnd(2) to opnd(1) by opnd(3) units */ 22 27 make_desc initial("000110110"b), /* opnd(1) <- descriptor(opnd(2),opnd(3)) */ 22 28 assign_round initial("000110111"b), /* opnd(1) <- opnd(2) rounded */ 22 29 pack initial("000111000"b), /* opnd(1) <- encode to picture opnd(2) */ 22 30 unpack initial("000111001"b), /* opnd(1) <- decode from picture opnd(2) */ 22 31 22 32 less_than initial("001000100"b), /* opnd(1) <- opnd(2) < opnd(3) */ 22 33 greater_than initial("001000101"b), /* opnd(1) <- opnd(2) > opnd(3) */ 22 34 equal initial("001000110"b), /* opnd(1) <- opnd(2) = opnd(3) */ 22 35 not_equal initial("001000111"b), /* opnd(1) <- opnd(2) ^= opnd(3) */ 22 36 less_or_equal initial("001001000"b), /* opnd(1) <- opnd(2) <= opnd(3) */ 22 37 greater_or_equal initial("001001001"b), /* opnd(1) <- opnd(2) >= opnd(3) */ 22 38 22 39 jump initial("001010001"b), /* go to opnd(1) unconditionally */ 22 40 jump_true initial("001010010"b), /* go to opnd(1) if opnd(2) is not 0 */ 22 41 jump_false initial("001010011"b), /* go to opnd(1) if opnd(2) is all 0 */ 22 42 jump_if_lt initial("001010100"b), /* go to opnd(1) if opnd(2) < opnd(3) */ 22 43 jump_if_gt initial("001010101"b), /* go to opnd(1) if opnd(2) > opnd(3) */ 22 44 jump_if_eq initial("001010110"b), /* go to opnd(1) if opnd(2) = opnd(3) */ 22 45 jump_if_ne initial("001010111"b), /* go to opnd(1) if opnd(2) ^= opnd(3) */ 22 46 jump_if_le initial("001011000"b), /* go to opnd(1) if opnd(2) <= opnd(3) */ 22 47 jump_if_ge initial("001011001"b), /* go to opnd(1) if opnd(2) >= opnd(3) */ 22 48 22 49 std_arg_list initial("001100001"b), /* opnd(1) <- arglist(opnd(2) desclist(opnd(3))) */ 22 50 return_words initial("001100010"b), /* return aggregate opnd(1), opnd(2) is length in words */ 22 51 std_call initial("001100011"b), /* opnd(1) <- call opnd(2) with opnd(3) */ 22 52 return_bits initial("001100100"b), /* return aggregate opnd(1), opnd(2) is length in bits */ 22 53 std_entry initial("001100101"b), /* entry(opnd(1)... opnd(n)) */ 22 54 return_string initial("001100110"b), /* return string opnd(1) */ 22 55 ex_prologue initial("001100111"b), /* execute the prologue -no operands- */ 22 56 allot_auto initial("001101000"b), /* opnd(1) <- addrel(stack,opnd(2)) */ 22 57 param_ptr initial("001101001"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 22 58 param_desc_ptr initial("001101010"b), /* opnd(1) <- ptr to opnd(2) in block opnd(3) */ 22 59 std_return initial("001101011"b), /* return -no arguments- */ 22 60 allot_ctl initial("001101100"b), /* allocate opnd(1) , length in words is opnd(2) */ 22 61 free_ctl initial("001101101"b), /* free opnd(1) */ 22 62 stop initial("001101110"b), /* stop - terminate run unit */ 22 63 22 64 mod_bit initial("001110000"b), /* opnd(1) <- mod(opnd(3),36), 22 65* opnd(2) <- opnd(3) / 36 */ 22 66 mod_byte initial("001110001"b), /* opnd(1) <- mod(opnd(3),4), 22 67* opnd(2) <- opnd(3) / 4 */ 22 68 mod_half initial("001110010"b), /* opnd(1) <- mod(opnd(3),2), 22 69* opnd(2) <- opnd(3) / 2 */ 22 70 mod_word initial("001110011"b), /* TO BE DEFINED BY BLW */ 22 71 22 72 bit_to_char initial("010000000"b), /* opnd(1) <- (opnd(2)+8)/9 */ 22 73 bit_to_word initial("010000001"b), /* opnd(1) <- (opnd(2)+35)/36 */ 22 74 char_to_word initial("010000010"b), /* opnd(1) <- (opnd(2)+3)/4 */ 22 75 half_to_word initial("010000011"b), /* opnd(1) <- (opnd(2)+1)/2 */ 22 76 word_to_mod2 initial("010000100"b), /* opnd(1) <- (opnd(2)+1)/2*2 */ 22 77 word_to_mod4 initial("010000101"b), /* opnd(1) <- (opnd(2)+3)/4*4 */ 22 78 word_to_mod8 initial("010000110"b), /* opnd(1) <- (opnd(2)+7)/8*8 */ 22 79 rel_fun initial("010000111"b), /* opnd(1) <- rel(opnd(2)) */ 22 80 baseno_fun initial("010001000"b), /* opnd(1) <- baseno(opnd(2)) */ 22 81 desc_size initial("010001001"b), /* opnd(1) <- substr(opnd(2),13,24) */ 22 82 bit_pointer initial("010001010"b), /* opnd(1) <- bit offset of opnd(2) */ 22 83 index_before_fun initial("010001011"b), /* opnd(1) <- length of before(opnd(2),opnd(3)) */ 22 84 index_after_fun initial("010001100"b), /* opnd(1) <- offset of after(opnd(2),opnd(3)) in opnd(2) */ 22 85 verify_ltrim_fun initial("010001101"b), /* opnd(1) <- offset of ltrim(opnd(2),opnd(3)) in opnd(2) */ 22 86 verify_rtrim_fun initial("010001110"b), /* opnd(1) <- length(opnd(2))-length(rtrim(opnd(2),opnd(3))) */ 22 87 digit_to_bit initial("010001111"b), /* opnd(1) <- 9*opnd(2)/2 */ 22 88 22 89 ceil_fun initial("010010000"b), /* opnd(1) <- ceil(opnd(2)) */ 22 90 floor_fun initial("010010001"b), /* opnd(1) <- floor(opnd(2)) */ 22 91 round_fun initial("010010010"b), /* opnd(1) <- round(opnd(2)) */ 22 92 sign_fun initial("010010011"b), /* opnd(1) <- sign(opnd(2)) */ 22 93 abs_fun initial("010010100"b), /* opnd(1) <- abs(opnd(2)) */ 22 94 trunc_fun initial("010010101"b), /* opnd(1) <- trunc(opnd(2)) */ 22 95 byte_fun initial("010010110"b), /* opnd(1) <- byte(opnd(2)) */ 22 96 rank_fun initial("010010111"b), /* opnd(1) <- rank(opnd(2)) */ 22 97 index_rev_fun initial("010011000"b), /* opnd(1) <- index(reverse(opnd(2)),reverse(opnd(3))) */ 22 98 search_rev_fun initial("010011001"b), /* opnd(1) <- search(reverse(opnd(2)),opnd(3)) */ 22 99 verify_rev_fun initial("010011010"b), /* opnd(1) <- verify(reverse(opnd(2)),opnd(3)) */ 22 100 wordno_fun initial("010011011"b), /* opnd(1) <- wordno (opnd(2)) */ 22 101 segno_fun initial("010011100"b), /* opnd(1) <- segno (opnd(2)) */ 22 102 bitno_fun initial("010011101"b), /* opnd(1) <- bitno (opnd(2)) */ 22 103 charno_fun initial("010011110"b), /* opnd(1) <- charno (opnd(2)) */ 22 104 22 105 index_fun initial("010100000"b), /* opnd(1) <- index(opnd(2),opnd(3)) */ 22 106 off_fun initial("010100001"b), /* opnd(1) <- offset(opnd(2),opnd(3)) */ 22 107 complex_fun initial("010100010"b), /* opnd(1) <- complex(opnd(2),opnd(3)) */ 22 108 conjg_fun initial("010100011"b), /* opnd(1) <- conjg(opnd(2),opnd(3)) */ 22 109 mod_fun initial("010100100"b), /* opnd(1) <- mod(opnd(2),opnd(3)) */ 22 110 repeat_fun initial("010100101"b), /* opnd(1) <- repeat(opnd(2),opnd(3)) */ 22 111 verify_fun initial("010100110"b), /* opnd(1) <- verify(opnd(2),opnd(3)) */ 22 112 translate_fun initial("010100111"b), /* opnd(1) <- translate(opnd(2),opnd(3))*/ 22 113 real_fun initial("010101001"b), /* opnd(1) <- real(opnd(2)) */ 22 114 imag_fun initial("010101010"b), /* opnd(1) <- imag(opnd(2)) */ 22 115 length_fun initial("010101011"b), /* opnd(1) <- length(opnd(2)) */ 22 116 pl1_mod_fun initial("010101100"b), /* opnd(1) <- mod(opnd(2)) */ 22 117 search_fun initial("010101101"b), /* opnd(1) <- search(opnd(2),opnd(3)) */ 22 118 allocation_fun initial("010101110"b), /* opnd(1) <- allocation(opnd(2)) */ 22 119 reverse_fun initial("010101111"b), /* opnd(1) <- reverse(opnd(2)) */ 22 120 22 121 addr_fun initial("010110000"b), /* opnd(1) <- addr(opnd(2)) */ 22 122 addr_fun_bits initial("010110001"b), /* opnd(1) <- addr(opnd(2)) */ 22 123 ptr_fun initial("010110010"b), /* opnd(1) <- ptr(opnd(2),opnd(3)) */ 22 124 baseptr_fun initial("010110011"b), /* opnd(1) <- baseptr(opnd(2)) */ 22 125 addrel_fun initial("010110100"b), /* opnd(1) <- addrel(opnd(2),opnd(3)) */ 22 126 codeptr_fun initial("010110101"b), /* opnd(1) <- codeptr(opnd(2)) */ 22 127 environmentptr_fun initial("010110110"b), /* opnd(1) <- environmentptr(opnd(2)) */ 22 128 stackbaseptr_fun initial("010110111"b), /* opnd(1) is ptr to base of current stack */ 22 129 stackframeptr_fun initial("010111000"b), /* opnd(1) is ptr to current block's stack frame */ 22 130 setcharno_fun initial("010111001"b), /* opnd(1) <- opnd(2) with charno opnd(3) */ 22 131 addcharno_fun initial("010111010"b), /* opnd(1) <- opnd(2) with charno = charno + opnd(3) */ 22 132 setbitno_fun initial("010111011"b), /* setcharno for bitsno */ 22 133 addbitno_fun initial("010111100"b), /* addcharno for bitno */ 22 134 22 135 min_fun initial("011000000"b), /* opnd(1) <- min(opnd(1),opnd(2),...) */ 22 136 max_fun initial("011000001"b), /* opnd(1) <- max(opnd(1),opnd(2),...) */ 22 137 22 138 stack_ptr initial("011010001"b), /* opnd(1) <- stack frame ptr */ 22 139 empty_area initial("011010010"b), /* empty opnd(1), length in words is opnd(2) */ 22 140 enable_on initial("011010100"b), /* opnd(1) is the cond name 22 141* opnd(2) is the file name 22 142* opnd(3) is the block */ 22 143 revert_on initial("011010101"b), /* opnd(1) is the cond name, 22 144* opnd(2) is the file name */ 22 145 signal_on initial("011010110"b), /* opnd(1) is the cond name 22 146* opnd(2) is the file name */ 22 147 22 148 lock_fun initial("011010111"b), /* opnd(1) <- stac(opnd(2),opnd(3)) */ 22 149 stacq_fun initial("011011000"b), /* opnd(1) is result, opnd(2) is ptr to lock word, 22 150* opnd(3) is old value, (4) is new value. */ 22 151 clock_fun initial("011011001"b), /* opnd(1) is the clock time */ 22 152 vclock_fun initial("011011010"b), /* opnd(1) is the virtual clock time */ 22 153 22 154 bound_ck initial("011100000"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 22 155 range_ck initial("011100001"b), /* opnd(1) <- opnd(2) if opnd(3) <= opnd(2) <= opnd(4) */ 22 156 loop initial("011100010"b), /* do opnd(1) for opnd(2) from opnd(3) to opnd(4) by 1, 22 157* opnd(5) is the list */ 22 158 join initial("011100011"b), /* do opnd(1), opnd(2) ... opnd(n) */ 22 159 allot_based initial("011100100"b), /* allocate opnd(2) words in opnd(3), set opnd(1) */ 22 160 free_based initial("011100101"b), /* free opnd(1) in opnd(3), length is opnd(2) words */ 22 161 22 162 r_parn initial("011110001"b), /* format op code */ 22 163 l_parn initial("011110010"b), 22 164 r_format initial("011110011"b), 22 165 c_format initial("011110100"b), 22 166 f_format initial("011110101"b), 22 167 e_format initial("011110110"b), 22 168 b_format initial("011110111"b), 22 169 a_format initial("011111000"b), 22 170 x_format initial("011111001"b), 22 171 skip_format initial("011111010"b), 22 172 column_format initial("011111011"b), 22 173 page_format initial("011111100"b), 22 174 line_format initial("011111101"b), 22 175 picture_format initial("011111110"b), 22 176 bn_format initial("011111111"b), /* bit format, length(opnd(2)), radix factor(opnd(3)) */ 22 177 22 178 get_list_trans initial("100000000"b), /* getlist(opnd(2) with desc(opnd(1))) */ 22 179 get_edit_trans initial("100000001"b), /* getedit(opnd(2) with desc(opnd(1))) */ 22 180 get_data_trans initial("100000010"b), /* getdata(opnd(1) to opnd(n)) */ 22 181 put_list_trans initial("100000011"b), /* putlist(opnd(2) with desc(opnd(1))) */ 22 182 put_edit_trans initial("100000100"b), /* putedit(opnd(2) with desc(opnd(1))) */ 22 183 put_data_trans initial("100000101"b), /* putdata(opnd(2)) with subscript-list opnd(1) */ 22 184 terminate_trans initial("100000110"b), /* terminate stream transmission */ 22 185 stream_prep initial("100000111"b), /* initiate stream transmission */ 22 186 record_io initial("100001000"b), /* perform record io operation */ 22 187 fortran_read initial("100001001"b), /* A complete read statement */ 22 188 fortran_write initial("100001010"b), /* A complete write statement */ 22 189 ftn_file_manip initial("100001011"b), /* endfile,backspace,rewind,etc. */ 22 190 ftn_trans_loop initial("100001100"b), /* An implied do in i/o list */ 22 191 put_control initial("100001101"b), /* put control opnd(1) opnd(2) times */ 22 192 put_field initial("100001110"b), /* putlist(opnd(2)) of length(opnd(1)) */ 22 193 put_field_chk initial("100001111"b), /* putlist(op(2)) of len(op(1)) check char index(op(3)) */ 22 194 22 195 /* These operators are produced by the parse but are not used as input to the code generator. */ 22 196 /* They are processed by the semantic translator. */ 22 197 22 198 return_value initial("100010010"b), /* return(opnd(1)) */ 22 199 allot_var initial("100010011"b), /* allot opnd(1) in opnd(2) */ 22 200 free_var initial("100010100"b), /* free opnd(1) out of opnd(2) */ 22 201 get_file initial("100010101"b), /* opnd(1) is filename,opnd(2) is copy */ 22 202 /* opnd(3) is skip, opnd(4) is list */ 22 203 get_string initial("100010110"b), /* opnd(1) is string,opnd(2) is list */ 22 204 put_file initial("100010111"b), /* opnd(1) is filename,opnd(2) is page */ 22 205 /* opnd(3) is skip,opnd(4) is line */ 22 206 put_string initial("100011000"b), /* opnd(1) is string,opnd(2) is list */ 22 207 open_file initial("100011001"b), 22 208 close_file initial("100011010"b), 22 209 read_file initial("100011011"b), 22 210 write_file initial("100011100"b), 22 211 locate_file initial("100011101"b), 22 212 do_fun initial("100011110"b), /* opnd(1) is join of a list */ 22 213 /* opnd(2) is control variable ref */ 22 214 /* opnd(3) is specification operator */ 22 215 do_spec initial("100011111"b), /* opnd(1) to opnd(2) by opnd(3) */ 22 216 /* repeat opnd(4) while opnd(5) */ 22 217 /* opnd(6) is next specification */ 22 218 22 219 rewrite_file initial("100100000"b), 22 220 delete_file initial("100100001"b), 22 221 unlock_file initial("100100010"b), 22 222 lock_file initial("100100011"b), 22 223 refer initial("100100101"b), /* opnd(1) refer(opnd(2)) */ 22 224 prefix_plus initial("100100110"b), /* opnd(1) <- +opnd(2) */ 22 225 nop initial("100100111"b), /* no-op */ 22 226 assign_by_name initial("100101000"b), /* opnd(1) <- opnd(2),by name */ 22 227 22 228 /* These operators are produced by the semantic translator in processing the math 22 229* builtin functions and are used as input to the code generator */ 22 230 22 231 sqrt_fun initial("100110000"b), /* opnd(1) <- sqrt(opnd(2)) */ 22 232 sin_fun initial("100110001"b), /* opnd(1) <- sin(opnd(2)) */ 22 233 sind_fun initial("100110010"b), /* opnd(1) <- sind(opnd(2)) */ 22 234 cos_fun initial("100110011"b), /* opnd(1) <- cos(opnd(2)) */ 22 235 cosd_fun initial("100110100"b), /* opnd(1) <- cosd(opnd(2)) */ 22 236 tan_fun initial("100110101"b), /* opnd(1) <- tan(opnd(2)) */ 22 237 tand_fun initial("100110110"b), /* opnd(1) <- tand(opnd(2)) */ 22 238 asin_fun initial("100110111"b), /* opnd(1) <- asin(opnd(2)) */ 22 239 asind_fun initial("100111000"b), /* opnd(1) <- asind(opnd(2)) */ 22 240 acos_fun initial("100111001"b), /* opnd(1) <- acos(opnd(2)) */ 22 241 acosd_fun initial("100111010"b), /* opnd(1) <- acosd(opnd(2)) */ 22 242 atan_fun initial("100111011"b), /* opnd(1) <- atan(opnd(2)[,opnd(3)]) */ 22 243 atand_fun initial("100111100"b), /* opnd(1) <- atand(opnd(2)[,opnd(3)]) */ 22 244 log2_fun initial("100111101"b), /* opnd(1) <- log2(opnd(2)) */ 22 245 log_fun initial("100111110"b), /* opnd(1) <- log(opnd(2)) */ 22 246 log10_fun initial("100111111"b), /* opnd(1) <- log10(opnd(2)) */ 22 247 22 248 exp_fun initial("101000000"b)) /* opnd(1) <- exp(opnd(2)) */ 22 249 22 250 bit(9) aligned internal static options(constant); 22 251 22 252 /* END INCLUDE FILE ... op_codes.incl.pl1 */ 1083 23 1 /* BEGIN INCLUDE FILE ... operator.incl.pl1 */ 23 2 23 3 /* Modified: 2 Apr 1980 by PCK to add max_number_of_operands */ 23 4 23 5 /* format: style3 */ 23 6 dcl 1 operator based aligned, 23 7 2 node_type bit (9) unaligned, 23 8 2 op_code bit (9) unaligned, 23 9 2 shared bit (1) unaligned, 23 10 2 processed bit (1) unaligned, 23 11 2 optimized bit (1) unaligned, 23 12 2 number fixed (14) unaligned, 23 13 2 operand dimension (n refer (operator.number)) ptr unaligned; 23 14 23 15 dcl max_number_of_operands 23 16 fixed bin (15) int static options (constant) initial (32767); 23 17 23 18 /* END INCLUDE FILE ... operator.incl.pl1 */ 1084 24 1 /* *********************************************************** 24 2* * * 24 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 24 4* * * 24 5* *********************************************************** */ 24 6 /* BEGIN INCLUDE FILE ... statement.incl.pl1 */ 24 7 /* Internal interface of the PL/I compiler */ 24 8 24 9 dcl 1 statement based aligned, 24 10 2 node_type bit(9) unaligned, 24 11 2 source_id structure unaligned, 24 12 3 file_number bit(8), 24 13 3 line_number bit(14), 24 14 3 statement_number bit(5), 24 15 2 next ptr unaligned, 24 16 2 back ptr unaligned, 24 17 2 root ptr unaligned, 24 18 2 labels ptr unaligned, 24 19 2 reference_list ptr unaligned, 24 20 2 state_list ptr unaligned, 24 21 2 reference_count fixed(17) unaligned, 24 22 2 ref_count_copy fixed(17) unaligned, 24 23 2 object structure unaligned, 24 24 3 start fixed(17), 24 25 3 finish fixed(17), 24 26 2 source structure unaligned, 24 27 3 segment fixed(11), 24 28 3 start fixed(23), 24 29 3 length fixed(11), 24 30 2 prefix bit(12) unaligned, 24 31 2 optimized bit(1) unaligned, 24 32 2 free_temps bit(1) unaligned, 24 33 2 LHS_in_RHS bit(1) unaligned, 24 34 2 statement_type bit(9) unaligned, 24 35 2 bits structure unaligned, 24 36 3 processed bit(1) unaligned, 24 37 3 put_in_profile bit(1) unaligned, 24 38 3 generated bit(1) unaligned, 24 39 3 snap bit(1) unaligned, 24 40 3 system bit(1) unaligned, 24 41 3 irreducible bit(1) unaligned, 24 42 3 checked bit(1) unaligned, 24 43 3 save_temps bit(1) unaligned, 24 44 3 suppress_warnings bit(1) unaligned, 24 45 3 force_nonquick bit(1) unaligned, 24 46 3 expanded_by_name bit(1) unaligned, 24 47 3 begins_loop bit(1) unaligned, 24 48 3 pad bit(24) unaligned; 24 49 24 50 /* END INCLUDE FILE ... statement.incl.pl1 */ 1085 25 1 /* statement types */ 25 2 25 3 dcl ( unknown_statement initial("000000000"b), 25 4 allocate_statement initial("000000001"b), 25 5 assignment_statement initial("000000010"b), 25 6 begin_statement initial("000000011"b), 25 7 call_statement initial("000000100"b), 25 8 close_statement initial("000000101"b), 25 9 declare_statement initial("000000110"b), 25 10 lock_statement initial("000000111"b), 25 11 delete_statement initial("000001000"b), 25 12 display_statement initial("000001001"b), 25 13 do_statement initial("000001010"b), 25 14 else_clause initial("000001011"b), 25 15 end_statement initial("000001100"b), 25 16 entry_statement initial("000001101"b), 25 17 exit_statement initial("000001110"b), 25 18 format_statement initial("000001111"b), 25 19 free_statement initial("000010000"b), 25 20 get_statement initial("000010001"b), 25 21 goto_statement initial("000010010"b), 25 22 if_statement initial("000010011"b), 25 23 locate_statement initial("000010100"b), 25 24 null_statement initial("000010101"b), 25 25 on_statement initial("000010110"b), 25 26 open_statement initial("000010111"b), 25 27 procedure_statement initial("000011000"b), 25 28 put_statement initial("000011001"b), 25 29 read_statement initial("000011010"b), 25 30 return_statement initial("000011011"b), 25 31 revert_statement initial("000011100"b), 25 32 rewrite_statement initial("000011101"b), 25 33 signal_statement initial("000011110"b), 25 34 stop_statement initial("000011111"b), 25 35 system_on_unit initial("000100000"b), 25 36 unlock_statement initial("000100001"b), 25 37 wait_statement initial("000100010"b), 25 38 write_statement initial("000100011"b), 25 39 default_statement initial("000100100"b), 25 40 continue_statement initial("000100101"b)) bit(9) internal static aligned options(constant); 1086 26 1 26 2 /* ps_map.incl.pl1 for PLIO2 */ 26 3 dcl ( ps_stack init(0), 26 4 ps_symbol_top init(2), 26 5 ps_symbol_block init(4), 26 6 ps_format_area init(6), 26 7 ps_ssl init(8), 26 8 ps_label init(10), 26 9 ps_source init(16), 26 10 ps_special_list init(18), 26 11 ps_set_p init(18), 26 12 ps_copy init(20), 26 13 ps_var_bitlen init(21), 26 14 ps_job init(22), 26 15 ps_number init(23), 26 16 ps_value init(24), 26 17 ps_var_p init(24), 26 18 ps_descriptor init(26), 26 19 ps_offset init(28), 26 20 ps_prep init(29), 26 21 ps_lock_sw init(29), 26 22 ps_new_format init(30), 26 23 ps_key init(48) ) fixed bin(15) static internal options(constant); 26 24 1087 27 1 /* BEGIN INCLUDE FILE ... cross_reference.incl.pl1 */ 27 2 27 3 dcl 1 cross_reference based aligned, 27 4 2 node_type bit(9) unaligned, 27 5 2 source_id structure unaligned, 27 6 3 file_number bit(8), 27 7 3 line_number bit(14), 27 8 3 statement_number bit(5), 27 9 2 next ptr unaligned, 27 10 2 ref_type structure unaligned, 27 11 3 set_reference bit(1), 27 12 3 pad bit(35); 27 13 27 14 /* END INCLUDE FILE ... cross_reference.incl.pl1 */ 1088 1089 end /* io_data_list_semantics */; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/05/00 1826.8 io_data_list_semantics.pl1 >udd>sm>ds>w>ml>io_data_list_semantics.pl1 1066 1 07/21/80 1646.3 semant.incl.pl1 >ldd>incl>semant.incl.pl1 1-228 2 08/01/89 1339.9 language_utility.incl.pl1 >ldd>incl>language_utility.incl.pl1 2-307 3 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-325 4 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-335 5 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-374 6 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 2-386 7 05/06/74 1846.9 source_id_descriptor.incl.pl1 >ldd>incl>source_id_descriptor.incl.pl1 1067 8 06/28/79 1304.8 picture_image.incl.pl1 >ldd>incl>picture_image.incl.pl1 1068 9 07/21/80 1646.3 nodes.incl.pl1 >ldd>incl>nodes.incl.pl1 1069 10 12/07/83 1801.7 system.incl.pl1 >ldd>incl>system.incl.pl1 1070 11 11/30/78 1327.5 mask.incl.pl1 >ldd>incl>mask.incl.pl1 1071 12 07/21/80 1646.3 reference.incl.pl1 >ldd>incl>reference.incl.pl1 1072 13 08/13/81 2143.5 block.incl.pl1 >ldd>incl>block.incl.pl1 1073 14 09/14/77 1805.7 token.incl.pl1 >ldd>incl>token.incl.pl1 1074 15 11/30/78 1327.4 token_types.incl.pl1 >ldd>incl>token_types.incl.pl1 1075 16 07/21/80 1646.3 semantic_bits.incl.pl1 >ldd>incl>semantic_bits.incl.pl1 1076 17 12/07/83 1801.7 symbol.incl.pl1 >ldd>incl>symbol.incl.pl1 1079 18 10/25/79 1745.8 boundary.incl.pl1 >ldd>incl>boundary.incl.pl1 1080 19 10/25/79 1745.8 declare_type.incl.pl1 >ldd>incl>declare_type.incl.pl1 1081 20 05/06/74 1842.1 label.incl.pl1 >ldd>incl>label.incl.pl1 1082 21 08/13/81 2311.5 list.incl.pl1 >ldd>incl>list.incl.pl1 1083 22 04/07/83 1735.0 op_codes.incl.pl1 >ldd>incl>op_codes.incl.pl1 1084 23 07/21/80 1646.3 operator.incl.pl1 >ldd>incl>operator.incl.pl1 1085 24 04/07/83 1735.0 statement.incl.pl1 >ldd>incl>statement.incl.pl1 1086 25 05/03/76 1420.4 statement_types.incl.pl1 >ldd>incl>statement_types.incl.pl1 1087 26 05/03/76 1420.4 ps_map.incl.pl1 >ldd>incl>ps_map.incl.pl1 1088 27 10/25/79 1745.8 cross_reference.incl.pl1 >ldd>incl>cross_reference.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 000714 automatic pointer dcl 992 set ref 998* 1001 1003 1003 1003 1009 1009 a_format constant bit(9) initial dcl 22-8 ref 273 277 addr_fun 000007 constant bit(9) initial dcl 22-8 set ref 114* aggregate based bit(1) level 2 packed packed unaligned dcl 16-8 ref 692 792 aliasable 32(35) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 89* aligned 31(21) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 89* aligned_mask constant bit(36) initial dcl 11-3 ref 331 582 1041 assign 000011 constant bit(9) initial dcl 22-8 set ref 108* 112* 567 assign_round constant bit(9) initial dcl 22-8 ref 567 assignment_statement 000022 constant bit(9) initial dcl 25-3 set ref 78* 876* 928* attributes 31 based structure level 2 dcl 17-3 set ref 331 854 1041 b 000716 automatic pointer dcl 992 in procedure "compare_format" set ref 999* 1001 1003 1003 1003 1008 1009 1009 b parameter pointer dcl 44 in procedure "io_data_list_semantics" set ref 11 67 86 101 102 110 113 118* 123* 152* 652 654 655 665* 677* 691* 745 767* 775* 792* 879* b_format constant bit(9) initial dcl 22-8 ref 273 back 2 based pointer level 2 packed packed unaligned dcl 24-9 ref 78 116 876 928 952 bbin35 based fixed bin(35,0) dcl 39 ref 287 429 432 465 509 509 541 544 547 577 579 587 binary 31(29) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 89* bit_type 000027 constant bit(36) initial dcl 10-71 set ref 279* bits 13 based structure level 2 packed packed unaligned dcl 24-9 block based structure level 1 dcl 13-5 block_node 4 based pointer level 2 packed packed unaligned dcl 17-3 ref 471 bn_format constant bit(9) initial dcl 22-8 ref 507 brother 20 based pointer level 2 packed packed unaligned dcl 17-3 ref 860 bx 000226 automatic pointer dcl 27 set ref 67* 68 69 70* 70 745* 747 748 749* 749 820* 822 823 824 by_compiler 000012 constant bit(3) initial dcl 19-5 set ref 88* 118* 879* c_dcl_size 30 based fixed bin(24,0) level 2 dcl 17-3 set ref 95* 331 585 1041 c_format constant bit(9) initial dcl 22-8 ref 489 701 714 c_format_ptr 000254 automatic pointer dcl 27 set ref 327* 1052 1055 c_length 000614 automatic fixed bin(31,0) dcl 38 in procedure "io_data_list_semantics" set ref 287* 293* 295* 295* c_length 2 based fixed bin(24,0) level 2 in structure "reference" dcl 12-3 in procedure "io_data_list_semantics" ref 316 565 640 645 c_offset 1 based fixed bin(24,0) level 2 dcl 12-3 set ref 100* char 31(04) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 348 char_type 000015 constant bit(36) initial dcl 10-71 set ref 295* 295* 299* chars 2 based char level 2 dcl 8-6 ref 611 column_format constant bit(9) initial dcl 22-8 ref 222 compare_expression 000024 constant entry external dcl 2-48 ref 1009 compiler_developed 32(35) based structure level 3 packed packed unaligned dcl 17-3 complex 31(31) based bit(1) level 4 packed packed unaligned dcl 17-3 ref 329 complex_bit parameter bit(1) dcl 634 set ref 629 636* complex_mask constant bit(36) initial dcl 11-3 ref 331 1041 computational_mask 000014 constant bit(36) initial dcl 11-41 ref 854 constant 32(16) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 119* 284 423 461 501 constant_operands 000575 automatic fixed bin(15,0) dcl 36 set ref 450* 453* 455* 457 context 000626 automatic bit(36) dcl 16-5 set ref 148* 152* 675* 677* 690* 691* 692 766* 767* 774* 775* 792 context_with_top_bit_on constant bit(36) initial dcl 21 ref 471 convert$from_builtin 000026 constant entry external dcl 2-72 ref 279 299 582 convert$to_target 000032 constant entry external dcl 2-88 ref 680 convert$to_target_fb 000030 constant entry external dcl 2-82 ref 295 566 648 copy_expression 000034 constant entry external dcl 2-94 ref 101 copy_unique_expression 000036 constant entry external dcl 2-103 ref 236 294 create_label 000040 constant entry external dcl 2-140 ref 879 create_list 000042 constant entry external dcl 2-147 ref 820 881 create_operator 000044 constant entry external dcl 2-152 ref 107 108 112 114 234 280 311 328 336 363 387 562 619 639 644 739 908 942 create_statement 000046 constant entry external dcl 2-163 ref 78 116 876 928 952 create_symbol 000050 constant entry external dcl 2-184 ref 88 118 create_token 000052 constant entry external dcl 2-191 ref 376 376 cross_reference based structure level 1 dcl 27-3 cross_references 10 based pointer level 2 packed packed unaligned dcl 17-3 ref 841 841 850 ctl_cnt 000613 automatic fixed bin(15,0) dcl 36 set ref 161* 171* 171 172 177* 212* 239* 239 240 385 387 388 391 395 398* ctl_pointer 000262 automatic pointer array packed unaligned dcl 30 set ref 240* 389 ctli 000577 automatic fixed bin(15,0) dcl 36 set ref 220* 222* 224* 226* 228* 230* 232 235 cur_rep 000612 automatic fixed bin(15,0) dcl 36 set ref 160* 211* 973 980* 983* 983 data_format_found 000616 automatic bit(1) dcl 42 set ref 163* 176* 977 data_item_index 000611 automatic fixed bin(15,0) dcl 36 set ref 164* 178* 214* 251 253* data_type 31 based structure level 3 packed packed unaligned dcl 17-3 de 000602 automatic fixed bin(15,0) dcl 36 set ref 541* 543* 549 555 555 558 560 560 579* 585* 589 591 597 602 602 602 dec_integer 000013 constant bit(9) initial dcl 15-3 set ref 376* 376* decimal_mask constant bit(36) initial dcl 11-3 ref 582 declare 000012 constant entry external dcl 1-41 ref 96 declare_constant$integer 000054 constant entry external dcl 2-234 ref 109 235 238 316 565 570 640 641 645 declare_picture_temp 000056 constant entry external dcl 2-279 ref 564 636 declare_temporary 000060 constant entry external dcl 2-292 ref 115 295 295 312 331 680 680 1041 decode_complex_fun 000102 automatic bit(9) initial array dcl 23 set ref 23* 23* 336* 363* def_context based structure level 1 dcl 16-8 default_fix_bin_p 000020 constant fixed bin(31,0) initial dcl 10-5 set ref 680* 680* defined 32(13) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 89* 792 defined_reference 000014 constant entry external dcl 1-47 ref 792 do_fun constant bit(9) initial dcl 22-8 ref 187 901 do_statement 000001 constant bit(9) initial dcl 25-3 set ref 952* e_format constant bit(9) initial dcl 22-8 ref 450 509 574 705 element 1 based pointer array level 2 packed packed unaligned dcl 21-6 set ref 86 101 102* 110 113 822* 824* 882* expression_semantics 000016 constant entry external dcl 1-105 ref 152 471 677 691 767 775 f_format constant bit(9) initial dcl 22-8 ref 450 538 705 f_ptr 1 000362 automatic pointer array level 2 packed packed unaligned dcl 32 set ref 201 201 201 201 521* 985 father 1 based pointer level 2 in structure "block" packed packed unaligned dcl 13-5 in procedure "io_data_list_semantics" ref 70 749 father 17 based pointer level 2 in structure "symbol" packed packed unaligned dcl 17-3 in procedure "io_data_list_semantics" ref 837 843 first_peti 000605 automatic fixed bin(15,0) dcl 36 set ref 198* 201 201 fixed 31(01) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 89* float_mask constant bit(36) initial dcl 11-3 ref 582 flt 000620 automatic pointer dcl 46 set ref 660* 661 665* 672 672 677* 677* 678* 680* 680* 691* 691* 693* 694 694 695 703 705 705 705 726 fltt 000622 automatic pointer dcl 46 set ref 694* 695* 696 697 fop 000624 automatic bit(9) dcl 47 set ref 657* 687 688 701 710 714 format 31(15) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 119* 697 format_list_ptr_table 000362 automatic structure array level 1 dcl 32 set ref 518 format_op 000101 automatic bit(9) dcl 20 set ref 168 168 220 222 224 226 228 273 273 277 538 574 608 986* 1056* format_ptr 000246 automatic pointer dcl 27 set ref 219 236 246 284 284 287 294 305 327 541 544 547 577 579 587 610 985* 986 1055* 1056 1057 1057 format_statement 000000 constant bit(9) initial dcl 25-3 in procedure "io_data_list_semantics" set ref 116* format_statement 42(04) based bit(1) level 3 in structure "block" packed packed unaligned dcl 13-5 in procedure "io_data_list_semantics" set ref 654* generated 13(02) based bit(1) level 3 packed packed unaligned dcl 24-9 set ref 105* 117* 877* 929* 953* get_data 24(23) based bit(1) level 2 packed packed unaligned dcl 13-5 set ref 69* 748* get_data_trans constant bit(9) initial dcl 22-8 ref 59 get_edit_trans constant bit(9) initial dcl 22-8 ref 61 get_of_noncomputational 000615 automatic bit(1) dcl 42 set ref 797 835* 854* h 000100 automatic fixed bin(17,0) dcl 446 set ref 494* 496 497 498 498 501* hbound builtin function dcl 40 ref 518 i 000570 automatic fixed bin(15,0) dcl 36 in procedure "io_data_list_semantics" set ref 199* 268* 659* 660 663 670 685 714 726* 754* 763 817* i 000720 automatic fixed bin(17,0) dcl 993 in procedure "compare_format" set ref 1008* 1009 1009 1009 1009* i 000102 automatic fixed bin(17,0) dcl 446 in procedure "format_list_process" set ref 457* 458 458 461* i 000122 automatic fixed bin(15,0) dcl 892 in procedure "io_join_semantics" set ref 898* 900 904 915* imag_fun constant bit(9) initial dcl 22-8 ref 23 initial 11 based pointer level 2 packed packed unaligned dcl 17-3 set ref 120* 287 429 432 465 471 471 471 509 509 541 544 547 577 579 587 611 612 integer_type 000017 constant bit(36) initial dcl 10-71 set ref 312* 680* 680* io_data_list_semantics$format_list_semantics 000020 constant entry external dcl 1-120 ref 123 665 ip 000252 automatic pointer dcl 27 set ref 197* 253* 258* 261 263 267* 395 403 is_identifier constant bit(9) initial dcl 15-47 ref 672 it_factor 000362 automatic fixed bin(31,0) array level 2 dcl 32 set ref 520* 980 iteration_factor 000101 automatic fixed bin(17,0) dcl 446 set ref 465* 467* 476 483 520 j 000571 automatic fixed bin(15,0) dcl 36 in procedure "io_data_list_semantics" set ref 334* 335 336 339 344* 348* 354 355 363 368* 388* 389 389* j 000103 automatic fixed bin(17,0) dcl 446 in procedure "format_list_process" set ref 476* 483* j 000123 automatic fixed bin(15,0) dcl 892 in procedure "io_join_semantics" set ref 894* 898 919 933 946 963* 964 join 000006 constant bit(9) initial dcl 22-8 set ref 107* 156 178 189 248 328* 387* 739* 942* jp 000222 automatic pointer dcl 27 set ref 57* 64 74* 127* 141* 154* 156 156 178 178 180 248 252 253 258 733 739* 742 763 817 824 k 000573 automatic fixed bin(15,0) dcl 36 in procedure "io_data_list_semantics" set ref 497* 498 498 501* 623* 625* 717* 721* 723* 802* 806* 812* 814* 1022* 1025* 1028* 1030* k 000124 automatic fixed bin(15,0) dcl 892 in procedure "io_join_semantics" set ref 904* 917* 919 949 963 ki 000572 automatic fixed bin(15,0) dcl 36 set ref 544* 546* 564 l 000125 automatic fixed bin(15,0) dcl 892 set ref 919* 926 931 936 942* 945 l_parn constant bit(9) initial dcl 22-8 ref 480 687 label based structure level 1 dcl 20-1 labels 4 based pointer level 2 packed packed unaligned dcl 24-9 set ref 881* 882 length 6 based pointer level 2 packed packed unaligned dcl 12-3 ref 316 318 length_fun 000010 constant bit(9) initial dcl 22-8 set ref 311* length_ptr 000250 automatic pointer dcl 27 set ref 288* 294* 295* 295* 305 308* line_format constant bit(9) initial dcl 22-8 ref 168 226 list based structure level 1 dcl 21-6 loop constant bit(9) initial dcl 22-8 ref 194 432 loop_ptr 000260 automatic pointer dcl 27 set ref 264* 267* 391 394 400 402 m 000126 automatic fixed bin(15,0) dcl 892 set ref 945* 946 946* make_non_quick 000022 constant entry external dcl 1-162 ref 678 693 max_length_precision 000021 constant fixed bin(31,0) initial dcl 10-5 set ref 312* max_p_dec constant fixed bin(31,0) initial dcl 10-5 ref 570 misc_attributes 31(19) based structure level 3 packed packed unaligned dcl 17-3 n 000127 automatic fixed bin(15,0) dcl 892 in procedure "io_join_semantics" set ref 896* 898 917 936 949 964 n 000574 automatic fixed bin(15,0) dcl 36 in procedure "io_data_list_semantics" set ref 742* 743 754 next 1 based pointer level 2 packed packed unaligned dcl 24-9 ref 55 152 152 154 257 no_quick_edit 000617 automatic bit(1) initial dcl 43 set ref 43* 130 905* no_stack 24(22) based bit(1) level 2 packed packed unaligned dcl 13-5 set ref 655* node based structure level 1 dcl 9-27 nop 000002 constant bit(9) initial dcl 22-8 set ref 619* nss 000562 automatic pointer dcl 35 set ref 55* 78 116 876 928 952 null builtin function dcl 40 ref 64 68 78 78 86 88 88 88 88 115 115 116 116 118 118 137 246 264 288 305 312 312 316 331 331 391 400 448 458 465 496 498 509 625 625 661 680 680 680 680 723 723 733 747 772 773 792 792 807 816 838 841 851 854 858 876 876 879 879 895 928 928 952 952 1003 1003 1030 1030 1041 1041 1057 null_statement constant bit(9) initial dcl 25-3 ref 961 num parameter fixed bin(31,0) dcl 1050 ref 1049 1052 1055 num_eaten 000610 automatic fixed bin(15,0) dcl 36 set ref 197* 199 267* 268 number 0(21) based fixed bin(14,0) level 2 packed packed unaligned dcl 23-6 ref 156 219 450 492 494 497 509 659 742 896 1003 1003 1008 1052 1057 offset 5 based pointer level 2 packed packed unaligned dcl 12-3 ref 773 op 000224 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 108* 109 110 112* 113 114 op 000114 automatic pointer dcl 891 in procedure "io_join_semantics" set ref 908* 909 915 op_code 0(09) based bit(9) level 2 packed packed unaligned dcl 23-6 set ref 56 156 178 185 187 189 194 248 261 425 432 450 450 453 468 480 489 507 509 567 567* 657 705 705 705 901 986 1003 1003 1056 op_num 000606 automatic fixed bin(15,0) dcl 36 set ref 219* 236 246* 246 246* 247 282 305 541 544 579 587 1057* 1057* 1058 op_param parameter pointer dcl 417 ref 415 419 op_ptr 000100 automatic pointer dcl 417 set ref 419* 420 423 425 427 428 429 432 432 432 operand 1 based pointer array level 2 packed packed unaligned dcl 23-6 set ref 57 108* 109* 110* 112* 113* 114* 115* 121* 122 137 140 141 178 235* 236* 236 238* 246 253 263 284 284 287 294 295* 299* 301 301 301 303 305 312* 314* 314 319* 324 338* 339* 341* 344* 361 361 361 362* 362 362 365* 366* 366 366 367* 367 368* 374* 377* 389* 391* 394* 395* 402* 408* 420 423 425 428 428 429 432 432 432 458 458 461 465 465 470 482 496 496 497 498 498 498 498 501 501 509 509 509 524 541 544 547 565* 566* 567 567 567 567 567 567 570* 577 579 583 587 610 640* 641* 645* 648* 660 694 726* 739* 763 817* 900 909* 915* 933 946* 946 955 959* 1009 1009 1009 1009 1055 1057 operator based structure level 1 dcl 23-6 operator_node constant bit(9) initial dcl 9-5 ref 182 250 301 324 567 583 694 703 901 overlayed 33(11) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 89* p 000104 automatic pointer dcl 446 in procedure "format_list_process" set ref 448* 448* 450 450 450 453 458 458 461 465 465 468 470 480 482 489 492 494 496 497 498 498 501 507 509 509 509 509 509 521* 524 p 000206 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 280* 295 299 301 301 303 314 319 344 361 362 366 367 368 374 377 382* 391 394 397* 402 403* 406 408 562* 565 566 567 567 567 570 582* 583 583* 583 585 602* 605* 610* 611 612* 612 619* p 000674 automatic pointer dcl 631 in procedure "create_pic_ass_pf" set ref 639* 640 641 644* 645 648 649 p_param parameter pointer dcl 446 ref 444 448 p_str 000104 automatic varying char(256) dcl 25 set ref 558* 560* 564 611* 612* pa parameter pointer dcl 992 ref 990 998 pa_opnum 000603 automatic fixed bin(15,0) dcl 36 set ref 251* 408 pa_param parameter pointer dcl 417 set ref 415 427* 432* pa_ptr 000232 automatic pointer dcl 27 set ref 252* 257* 406 408 pa_type 000625 automatic bit(9) dcl 47 set ref 250* 256* 406 page_format constant bit(9) initial dcl 22-8 ref 224 pb parameter pointer dcl 992 ref 990 999 peti 000604 automatic fixed bin(15,0) dcl 36 set ref 162* 198 201 201 213* 974* 974 975 978* 980 985 pfc parameter bit(1) dcl 634 ref 629 637 piclength 0(27) based fixed bin(8,0) level 2 packed packed unaligned dcl 8-6 ref 611 picture_format constant bit(9) initial dcl 22-8 ref 608 705 710 picture_image based structure level 1 dcl 8-6 pl1_stat_$ok_list 000010 external static pointer dcl 41 set ref 822 823* plio_ps 17 based pointer level 2 packed packed unaligned dcl 13-5 ref 86 101 102 110 113 pointer_type 000016 constant bit(36) initial dcl 10-71 set ref 115* pp 000236 automatic pointer dcl 27 set ref 234* 235 236 238 240 277* 279* 295* 299* 301* 303* 309 316 316 318 387* 389 391 395 397 prefix 12(12) based bit(12) level 2 in structure "statement" packed packed unaligned dcl 24-9 in procedure "io_data_list_semantics" ref 53 prefix 000205 automatic bit(12) dcl 26 in procedure "io_data_list_semantics" set ref 53* 78* 116* 876* 928* 952* processed 13 based bit(1) level 3 in structure "statement" packed packed unaligned dcl 24-9 in procedure "io_data_list_semantics" set ref 105* 117* 877* 960* processed 0(19) based bit(1) level 2 in structure "operator" packed packed unaligned dcl 23-6 in procedure "io_data_list_semantics" set ref 337* 364* ps_new_format constant fixed bin(15,0) initial dcl 26-3 ref 110 ps_special_list constant fixed bin(15,0) initial dcl 26-3 ref 113 pti 000576 automatic fixed bin(15,0) dcl 36 set ref 133* 518 519* 519 520 521 975 put_control 000005 constant bit(9) initial dcl 22-8 set ref 234* put_data_trans constant bit(9) initial dcl 22-8 ref 64 put_edit_trans constant bit(9) initial dcl 22-8 ref 62 130 185 261 425 put_field 000004 constant bit(9) initial dcl 22-8 set ref 280* 644* put_field_chk 000003 constant bit(9) initial dcl 22-8 set ref 562* 639* put_in_symtab 33(08) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 839* 848* q 000116 automatic pointer dcl 891 in procedure "io_join_semantics" set ref 942* 946 q 000746 automatic pointer dcl 1038 in procedure "force_cplx_temp" set ref 1040* 1041 1041 1041 q 000106 automatic pointer dcl 446 in procedure "format_list_process" set ref 471* 477* 482* 484* q 000210 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 114* 115 121 336* 337 338 339 341 342* 361* 362* 365 q 000676 automatic pointer dcl 631 in procedure "create_pic_ass_pf" set ref 636* 640 645 648* q2 000256 automatic pointer dcl 27 set ref 363* 364 365 366 367 470* 471 471 471 471 q_param parameter pointer dcl 1038 ref 1036 1040 qualifier 4 based pointer level 2 packed packed unaligned dcl 12-3 set ref 101* 772 r 000106 automatic pointer dcl 875 in procedure "label_of_statement" set ref 879* 880 882 883 r 000212 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 78* 105 105 107 116* 117 117 120 122 123* 152 152 154 257 r_format constant bit(9) initial dcl 22-8 ref 453 468 688 randi 000110 automatic pointer dcl 891 set ref 900* 901 901 909 954 955 959 real_fun constant bit(9) initial dcl 22-8 ref 23 real_mask constant bit(36) initial dcl 11-3 ref 331 582 1041 ref_type 2 based structure level 2 packed packed unaligned dcl 27-3 reference based structure level 1 dcl 12-3 in procedure "io_data_list_semantics" reference 15 based pointer level 2 in structure "symbol" packed packed unaligned dcl 17-3 in procedure "io_data_list_semantics" ref 98 101 121 reference_node constant bit(9) initial dcl 9-5 ref 284 420 458 498 696 768 771 804 ri 000564 automatic pointer dcl 35 set ref 763* 764 767* 767* 768 771 772 773 775* 775* 788 792* 792* 804 809 816* 817 root 3 based pointer level 2 packed packed unaligned dcl 24-9 set ref 107* 122* 152* 152 154 406* 471 471* 933* 938* 942* 954* rr 000234 automatic pointer dcl 27 set ref 98* 99 100 101 102 564* 565 566* s parameter pointer dcl 875 in procedure "label_of_statement" set ref 872 876* 877 877 880 881 882 s 000112 automatic pointer dcl 891 in procedure "io_join_semantics" set ref 928* 929 933 938 942 952* 953 954 959* 960 961 s 000214 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 52* 53 55 767* 775* 792* s_param parameter pointer dcl 44 set ref 11 52 152* 652 665* 677* 691* scale 2(28) based fixed bin(7,0) level 2 packed packed unaligned dcl 17-3 ref 331 1041 scalefac parameter fixed bin(31,0) dcl 632 set ref 629 636* scalefactor 1(09) based fixed bin(8,0) level 2 packed packed unaligned dcl 8-6 ref 612 semantic_translator$abort 000062 constant entry external dcl 2-446 ref 625 1030 semantic_translator$error 000064 constant entry external dcl 2-450 ref 723 814 set 33(03) based bit(1) level 4 packed packed unaligned dcl 17-3 set ref 839* 848* set_reference 2 based bit(1) level 3 packed packed unaligned dcl 27-3 set ref 841* 851* share_expression 000066 constant entry external dcl 2-454 ref 308 314 318 341 359 359 si 000601 automatic fixed bin(15,0) dcl 36 set ref 587* 589* 591 594 597 599 602 602 605 605 skip_format constant bit(9) initial dcl 22-8 ref 220 son 21 based pointer level 2 packed packed unaligned dcl 17-3 ref 853 sp parameter pointer dcl 833 ref 832 837 846 848 848 850 853 854 statement 11 based pointer level 2 in structure "label" packed packed unaligned dcl 20-1 in procedure "io_data_list_semantics" set ref 880* statement based structure level 1 dcl 24-9 in procedure "io_data_list_semantics" statement_node 000022 constant bit(9) initial dcl 9-5 ref 256 406 statement_type 12(27) based bit(9) level 2 packed packed unaligned dcl 24-9 set ref 961* storage_class 32(09) based structure level 3 packed packed unaligned dcl 17-3 string builtin function dcl 40 set ref 148* 331 611 675* 690* 766* 774* 854 1041 substr builtin function dcl 40 ref 331 854 1041 sy 000566 automatic pointer dcl 35 set ref 788* 792 792* 796* 807* 809* 814* symbol based structure level 1 dcl 17-3 in procedure "io_data_list_semantics" symbol 3 based pointer level 2 in structure "reference" packed packed unaligned dcl 12-3 in procedure "io_data_list_semantics" ref 284 287 324 326 423 429 432 461 465 470 501 509 509 541 544 547 577 579 585 587 610 697 788 809 1041 1041 1041 t parameter pointer dcl 889 in procedure "io_join_semantics" ref 887 895 896 900 915 933 938 946 t parameter pointer dcl 45 in procedure "io_data_list_semantics" set ref 54* 56 57 122 137 140* 140 141 652 657 659 660 726 739 t_param parameter pointer dcl 44 ref 11 54 token based structure level 1 dcl 14-3 token_node constant bit(9) initial dcl 9-5 ref 672 764 tp 000220 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 118* 119 119 120 121 122* 123* 134* tp 000100 automatic pointer dcl 833 in procedure "walk" set ref 837* 838 839 839 841 841 843* 843 850* 851 851 853* 854 858 859* 860* 860 trans_op 000100 automatic bit(9) dcl 20 set ref 56* 59 61 62 64 130 908* tt 000120 automatic pointer dcl 891 in procedure "io_join_semantics" set ref 955* 956* tt 000216 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 88* 89 89 89 89 89 89 95 96* 98 107* 108 112 type based bit(9) level 2 in structure "node" packed packed unaligned dcl 9-27 in procedure "io_data_list_semantics" ref 182 284 301 324 420 458 498 567 583 672 694 696 703 764 768 771 804 901 type 0(09) based bit(9) level 2 in structure "token" packed packed unaligned dcl 14-3 in procedure "io_data_list_semantics" ref 672 unaligned_mask constant bit(36) initial dcl 11-3 ref 331 1041 uncomplex_temp 000244 automatic pointer dcl 27 set ref 331* 338 units 0(14) based fixed bin(3,0) level 2 packed packed unaligned dcl 12-3 set ref 99* v_str parameter varying char(256) dcl 633 ref 629 636 var_cnt 000607 automatic fixed bin(15,0) dcl 36 set ref 156* 158* 164 214 varying_ref 0(10) based bit(1) level 2 packed packed unaligned dcl 12-3 ref 309 vp 000664 automatic pointer dcl 534 in procedure "pef_format" set ref 536* 566* 582* 602* 605* 612* vp 000230 automatic pointer dcl 27 in procedure "io_data_list_semantics" set ref 178* 180* 182 185 187 189 194 197* 197* 263* 267* 277 279* 322* 324 324 326 339 341* 355* 359* 359* 373* vp_param parameter pointer dcl 417 in procedure "expand_loop_set_ptr" set ref 415 428* 432* vp_param parameter pointer dcl 534 in procedure "pef_format" ref 532 536 vq parameter pointer dcl 631 set ref 629 648* vs 000242 automatic pointer dcl 27 set ref 324* 326* 329 331 331 331 348 why_nonquick 42 based structure level 2 dcl 13-5 wi 000600 automatic fixed bin(15,0) dcl 36 set ref 547* 551 553 555 558 560 570 570 577* 578 594 599 602 605 word_ constant fixed bin(3,0) initial dcl 18-5 ref 99 wp 000240 automatic pointer dcl 27 set ref 305* 308* 311* 312 314 316* 318* 319 328* 344 368 374 377 382 x_format constant bit(9) initial dcl 22-8 ref 168 228 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. abs_fun internal static bit(9) initial dcl 22-8 acos_fun internal static bit(9) initial dcl 22-8 acosd_fun internal static bit(9) initial dcl 22-8 add internal static bit(9) initial dcl 22-8 addbitno_fun internal static bit(9) initial dcl 22-8 addcharno_fun internal static bit(9) initial dcl 22-8 addr_fun_bits internal static bit(9) initial dcl 22-8 addrel_fun internal static bit(9) initial dcl 22-8 adjust_count 000000 constant entry external dcl 2-20 alloc_semantics 000000 constant entry external dcl 1-7 alloc_semantics$init_only 000000 constant entry external dcl 1-12 allocate_statement internal static bit(9) initial dcl 25-3 allocation_fun internal static bit(9) initial dcl 22-8 allot_auto internal static bit(9) initial dcl 22-8 allot_based internal static bit(9) initial dcl 22-8 allot_ctl internal static bit(9) initial dcl 22-8 allot_var internal static bit(9) initial dcl 22-8 and internal static bit(9) initial dcl 15-3 and_bits internal static bit(9) initial dcl 22-8 area_mask internal static bit(36) initial dcl 11-3 arg_desc_type internal static bit(36) initial dcl 10-71 arg_descriptor_mask internal static bit(36) initial dcl 11-3 arithmetic_mask internal static bit(36) initial dcl 11-41 array_node internal static bit(9) initial dcl 9-5 arrow internal static bit(9) initial dcl 15-3 asin_fun internal static bit(9) initial dcl 22-8 asind_fun internal static bit(9) initial dcl 22-8 assign_by_name internal static bit(9) initial dcl 22-8 assign_size_ck internal static bit(9) initial dcl 22-8 assign_zero internal static bit(9) initial dcl 22-8 assignment internal static bit(9) initial dcl 15-3 asterisk internal static bit(9) initial dcl 15-3 atan_fun internal static bit(9) initial dcl 22-8 atand_fun internal static bit(9) initial dcl 22-8 baseno_fun internal static bit(9) initial dcl 22-8 baseptr_fun internal static bit(9) initial dcl 22-8 begin_statement internal static bit(9) initial dcl 25-3 bin_integer internal static bit(9) initial dcl 15-3 binary_mask internal static bit(36) initial dcl 11-3 binary_to_octal_string 000000 constant entry external dcl 2-38 binary_to_octal_var_string 000000 constant entry external dcl 2-43 bindec 000000 constant entry external dcl 2-23 bindec$vs 000000 constant entry external dcl 2-28 binoct 000000 constant entry external dcl 2-33 bit_ internal static fixed bin(3,0) initial dcl 18-5 bit_mask internal static bit(36) initial dcl 11-3 bit_pointer internal static bit(9) initial dcl 22-8 bit_string internal static bit(9) initial dcl 15-3 bit_to_char internal static bit(9) initial dcl 22-8 bit_to_word internal static bit(9) initial dcl 22-8 bitno_fun internal static bit(9) initial dcl 22-8 bits_per_binary_exponent internal static fixed bin(31,0) initial dcl 10-5 bits_per_character internal static fixed bin(31,0) initial dcl 10-5 bits_per_decimal_digit internal static fixed bin(31,0) initial dcl 10-5 bits_per_digit internal static fixed bin(31,1) initial dcl 10-69 bits_per_double internal static fixed bin(31,0) initial dcl 10-5 bits_per_half internal static fixed bin(31,0) initial dcl 10-5 bits_per_packed_ptr internal static fixed bin(31,0) initial dcl 10-5 bits_per_word internal static fixed bin(31,0) initial dcl 10-5 block_node internal static bit(9) initial dcl 9-5 bool_fun internal static bit(9) initial dcl 22-8 bound_ck internal static bit(9) initial dcl 22-8 bound_node internal static bit(9) initial dcl 9-5 builtin 000000 constant entry external dcl 1-17 builtin_mask internal static bit(36) initial dcl 11-3 builtin_type internal static bit(36) initial dcl 10-71 by_context internal static bit(3) initial dcl 19-5 by_declare internal static bit(3) initial dcl 19-5 by_explicit_context internal static bit(3) initial dcl 19-5 by_implication internal static bit(3) initial dcl 19-5 by_name_agg_node internal static bit(9) initial dcl 9-5 byte_fun internal static bit(9) initial dcl 22-8 call_statement internal static bit(9) initial dcl 25-3 cat internal static bit(9) initial dcl 15-3 cat_string internal static bit(9) initial dcl 22-8 ceil_fun internal static bit(9) initial dcl 22-8 char_mask internal static bit(36) initial dcl 11-3 char_string internal static bit(9) initial dcl 15-3 char_to_word internal static bit(9) initial dcl 22-8 character_ internal static fixed bin(3,0) initial dcl 18-5 characters_per_double internal static fixed bin(31,0) initial dcl 10-5 characters_per_half internal static fixed bin(31,0) initial dcl 10-5 characters_per_word internal static fixed bin(31,0) initial dcl 10-5 charno_fun internal static bit(9) initial dcl 22-8 check_star_extents 000000 constant entry external dcl 1-27 clock_fun internal static bit(9) initial dcl 22-8 close_file internal static bit(9) initial dcl 22-8 close_statement internal static bit(9) initial dcl 25-3 codeptr_fun internal static bit(9) initial dcl 22-8 colon internal static bit(9) initial dcl 15-3 comma internal static bit(9) initial dcl 15-3 compare_declaration 000000 constant entry external dcl 1-31 complex_fun internal static bit(9) initial dcl 22-8 complex_type internal static bit(36) initial dcl 10-71 condition_mask internal static bit(36) initial dcl 11-3 conjg_fun internal static bit(9) initial dcl 22-8 constant_length 000000 constant entry external dcl 2-54 context_node internal static bit(9) initial dcl 9-5 context_processor 000000 constant entry external dcl 1-38 continue_statement internal static bit(9) initial dcl 25-3 convert 000000 constant entry external dcl 2-60 convert$to_integer 000000 constant entry external dcl 2-66 convert$validate 000000 constant entry external dcl 2-78 convert_mask internal static bit(36) initial dcl 11-41 copy_expression$copy_sons 000000 constant entry external dcl 2-99 copy_string internal static bit(9) initial dcl 22-8 copy_words internal static bit(9) initial dcl 22-8 cos_fun internal static bit(9) initial dcl 22-8 cosd_fun internal static bit(9) initial dcl 22-8 create_array 000000 constant entry external dcl 2-108 create_block 000000 constant entry external dcl 2-112 create_bound 000000 constant entry external dcl 2-118 create_context 000000 constant entry external dcl 2-122 create_cross_reference 000000 constant entry external dcl 2-128 create_default 000000 constant entry external dcl 2-132 create_identifier 000000 constant entry external dcl 2-136 create_reference 000000 constant entry external dcl 2-158 create_statement$prologue 000000 constant entry external dcl 2-171 create_storage 000000 constant entry external dcl 2-179 create_token$init_hash_table 000000 constant entry external dcl 2-197 create_token$protected 000000 constant entry external dcl 2-199 cross_reference_node internal static bit(9) initial dcl 9-5 dec_integer_type internal static bit(36) initial dcl 10-71 decbin 000000 constant entry external dcl 2-206 declare_constant 000000 constant entry external dcl 2-211 declare_constant$bit 000000 constant entry external dcl 2-219 declare_constant$char 000000 constant entry external dcl 2-224 declare_constant$desc 000000 constant entry external dcl 2-229 declare_constant_mask internal static bit(36) initial dcl 11-41 declare_descriptor 000000 constant entry external dcl 2-239 declare_descriptor$ctl 000000 constant entry external dcl 2-249 declare_descriptor$param 000000 constant entry external dcl 2-259 declare_integer 000000 constant entry external dcl 2-269 declare_picture 000000 constant entry external dcl 2-274 declare_pointer 000000 constant entry external dcl 2-287 declare_statement internal static bit(9) initial dcl 25-3 declare_structure 000000 constant entry external dcl 1-44 decode_node_id 000000 constant entry external dcl 2-300 decode_source_id 000000 constant entry external dcl 2-306 def_this_context based structure level 1 dcl 16-27 default_area_size internal static fixed bin(31,0) initial dcl 10-5 default_fix_dec_p internal static fixed bin(31,0) initial dcl 10-5 default_flt_bin_p internal static fixed bin(31,0) initial dcl 10-5 default_flt_dec_p internal static fixed bin(31,0) initial dcl 10-5 default_node internal static bit(9) initial dcl 9-5 default_statement internal static bit(9) initial dcl 25-3 delete_file internal static bit(9) initial dcl 22-8 delete_statement internal static bit(9) initial dcl 25-3 desc_size internal static bit(9) initial dcl 22-8 digit_ internal static fixed bin(3,0) initial dcl 18-5 digit_to_bit internal static bit(9) initial dcl 22-8 dimensioned_mask internal static bit(36) initial dcl 11-3 display_statement internal static bit(9) initial dcl 25-3 div internal static bit(9) initial dcl 22-8 do_semantics 000000 constant entry external dcl 1-57 do_spec internal static bit(9) initial dcl 22-8 else_clause internal static bit(9) initial dcl 25-3 empty_area internal static bit(9) initial dcl 22-8 enable_on internal static bit(9) initial dcl 22-8 end_statement internal static bit(9) initial dcl 25-3 entry_mask internal static bit(36) initial dcl 11-3 entry_statement internal static bit(9) initial dcl 25-3 entry_var_type internal static bit(36) initial dcl 10-71 environmentptr_fun internal static bit(9) initial dcl 22-8 eq internal static bit(9) initial dcl 15-3 equal internal static bit(9) initial dcl 22-8 error 000000 constant entry external dcl 2-314 error$omit_text 000000 constant entry external dcl 2-319 error_ 000000 constant entry external dcl 2-324 error_$finish 000000 constant entry external dcl 2-343 error_$initialize_error 000000 constant entry external dcl 2-341 error_$no_text 000000 constant entry external dcl 2-334 ex_prologue internal static bit(9) initial dcl 22-8 exit_statement internal static bit(9) initial dcl 25-3 exp internal static bit(9) initial dcl 22-8 exp_fun internal static bit(9) initial dcl 22-8 expand_assign 000000 constant entry external dcl 1-62 expand_by_name 000000 constant entry external dcl 1-71 expand_infix 000000 constant entry external dcl 1-76 expand_initial 000000 constant entry external dcl 1-84 expand_prefix 000000 constant entry external dcl 1-89 expand_primitive 000000 constant entry external dcl 1-97 expon internal static bit(9) initial dcl 15-3 file_mask internal static bit(36) initial dcl 11-3 fill_refer 000000 constant entry external dcl 1-113 fixed_bin internal static bit(9) initial dcl 15-3 fixed_binary_real_mask internal static bit(36) initial dcl 11-41 fixed_dec internal static bit(9) initial dcl 15-3 fixed_decimal_complex_mask internal static bit(36) initial dcl 11-41 fixed_decimal_real_mask internal static bit(36) initial dcl 11-41 fixed_mask internal static bit(36) initial dcl 11-3 float_bin internal static bit(9) initial dcl 15-3 float_dec internal static bit(9) initial dcl 15-3 float_decimal_complex_mask internal static bit(36) initial dcl 11-41 float_decimal_real_mask internal static bit(36) initial dcl 11-41 floor_fun internal static bit(9) initial dcl 22-8 format_mask internal static bit(36) initial dcl 11-3 format_value_node internal static bit(9) initial dcl 9-5 fortran_read internal static bit(9) initial dcl 22-8 fortran_write internal static bit(9) initial dcl 22-8 free_based internal static bit(9) initial dcl 22-8 free_ctl internal static bit(9) initial dcl 22-8 free_node 000000 constant entry external dcl 2-345 free_statement internal static bit(9) initial dcl 25-3 free_var internal static bit(9) initial dcl 22-8 ftn_file_manip internal static bit(9) initial dcl 22-8 ftn_trans_loop internal static bit(9) initial dcl 22-8 function 000000 constant entry external dcl 1-125 ge internal static bit(9) initial dcl 15-3 generic_mask internal static bit(36) initial dcl 11-3 generic_selector 000000 constant entry external dcl 1-134 get_array_size 000000 constant entry external dcl 2-348 get_file internal static bit(9) initial dcl 22-8 get_list_trans internal static bit(9) initial dcl 22-8 get_size 000000 constant entry external dcl 2-352 get_statement internal static bit(9) initial dcl 25-3 get_string internal static bit(9) initial dcl 22-8 goto_statement internal static bit(9) initial dcl 25-3 greater_or_equal internal static bit(9) initial dcl 22-8 greater_than internal static bit(9) initial dcl 22-8 gt internal static bit(9) initial dcl 15-3 half_ internal static fixed bin(3,0) initial dcl 18-5 half_to_word internal static bit(9) initial dcl 22-8 i_bin_integer internal static bit(9) initial dcl 15-3 i_dec_integer internal static bit(9) initial dcl 15-3 i_fixed_bin internal static bit(9) initial dcl 15-3 i_fixed_dec internal static bit(9) initial dcl 15-3 i_float_bin internal static bit(9) initial dcl 15-3 i_float_dec internal static bit(9) initial dcl 15-3 identifier internal static bit(9) initial dcl 15-3 if_statement internal static bit(9) initial dcl 25-3 index_after_fun internal static bit(9) initial dcl 22-8 index_before_fun internal static bit(9) initial dcl 22-8 index_fun internal static bit(9) initial dcl 22-8 index_rev_fun internal static bit(9) initial dcl 22-8 initialed_mask internal static bit(36) initial dcl 11-3 io_data_list_semantics 000000 constant entry external dcl 1-143 io_semantics 000000 constant entry external dcl 1-148 irreducible_mask internal static bit(36) initial dcl 11-3 is_arith_constant internal static bit(9) initial dcl 15-47 is_arithmetic_constant internal static bit(9) initial dcl 15-47 is_constant internal static bit(9) initial dcl 15-47 is_decimal_constant internal static bit(9) initial dcl 15-47 is_delimiter internal static bit(9) initial dcl 15-47 is_float_constant internal static bit(9) initial dcl 15-47 is_imaginary_constant internal static bit(9) initial dcl 15-47 is_integral_constant internal static bit(9) initial dcl 15-47 is_isub internal static bit(9) initial dcl 15-47 isub internal static bit(9) initial dcl 15-3 jump internal static bit(9) initial dcl 22-8 jump_false internal static bit(9) initial dcl 22-8 jump_if_eq internal static bit(9) initial dcl 22-8 jump_if_ge internal static bit(9) initial dcl 22-8 jump_if_gt internal static bit(9) initial dcl 22-8 jump_if_le internal static bit(9) initial dcl 22-8 jump_if_lt internal static bit(9) initial dcl 22-8 jump_if_ne internal static bit(9) initial dcl 22-8 jump_true internal static bit(9) initial dcl 22-8 label_array_element_node internal static bit(9) initial dcl 9-5 label_mask internal static bit(36) initial dcl 11-3 label_node internal static bit(9) initial dcl 9-5 le internal static bit(9) initial dcl 15-3 left_parn internal static bit(9) initial dcl 15-3 less_or_equal internal static bit(9) initial dcl 22-8 less_than internal static bit(9) initial dcl 22-8 list_node internal static bit(9) initial dcl 9-5 local_label_var_type internal static bit(36) initial dcl 10-71 local_mask internal static bit(36) initial dcl 11-3 locate_file internal static bit(9) initial dcl 22-8 locate_statement internal static bit(9) initial dcl 25-3 lock_file internal static bit(9) initial dcl 22-8 lock_fun internal static bit(9) initial dcl 22-8 lock_mask internal static bit(36) initial dcl 11-3 lock_statement internal static bit(9) initial dcl 25-3 log10_fun internal static bit(9) initial dcl 22-8 log2_fun internal static bit(9) initial dcl 22-8 log_fun internal static bit(9) initial dcl 22-8 lookup 000000 constant entry external dcl 1-153 lt internal static bit(9) initial dcl 15-3 machine_state_node internal static bit(9) initial dcl 9-5 make_desc internal static bit(9) initial dcl 22-8 match_arguments 000000 constant entry external dcl 1-166 max_area_size internal static fixed bin(31,0) initial dcl 10-5 max_bit_string internal static fixed bin(31,0) initial dcl 10-5 max_bit_string_constant internal static fixed bin(31,0) initial dcl 10-5 max_block_number internal static fixed bin(17,0) initial dcl 13-74 max_char_string internal static fixed bin(31,0) initial dcl 10-5 max_char_string_constant internal static fixed bin(31,0) initial dcl 10-5 max_fun internal static bit(9) initial dcl 22-8 max_identifier_length internal static fixed bin(31,0) initial dcl 10-5 max_index_register_value internal static fixed bin(31,0) initial dcl 10-5 max_list_elements internal static fixed bin(17,0) initial dcl 21-12 max_number_of_dimensions internal static fixed bin(31,0) initial dcl 10-5 max_number_of_operands internal static fixed bin(15,0) initial dcl 23-15 max_offset_precision internal static fixed bin(31,0) initial dcl 10-5 max_p_bin_or_dec internal static fixed bin(31,0) initial dcl 10-5 max_p_fix_bin_1 internal static fixed bin(31,0) initial dcl 10-5 max_p_fix_bin_2 internal static fixed bin(31,0) initial dcl 10-5 max_p_flt_bin_1 internal static fixed bin(31,0) initial dcl 10-5 max_p_flt_bin_2 internal static fixed bin(31,0) initial dcl 10-5 max_scale internal static fixed bin(31,0) initial dcl 10-5 max_signed_index_register_value internal static fixed bin(31,0) initial dcl 10-5 max_signed_xreg_precision internal static fixed bin(31,0) initial dcl 10-5 max_uns_xreg_precision internal static fixed bin(31,0) initial dcl 10-5 max_words_per_variable internal static fixed bin(31,0) initial dcl 10-5 merge_attributes 000000 constant entry external dcl 2-355 min_area_size internal static fixed bin(31,0) initial dcl 10-5 min_fun internal static bit(9) initial dcl 22-8 min_scale internal static fixed bin(31,0) initial dcl 10-5 minus internal static bit(9) initial dcl 15-3 mod2_ internal static fixed bin(3,0) initial dcl 18-5 mod4_ internal static fixed bin(3,0) initial dcl 18-5 mod_bit internal static bit(9) initial dcl 22-8 mod_byte internal static bit(9) initial dcl 22-8 mod_fun internal static bit(9) initial dcl 22-8 mod_half internal static bit(9) initial dcl 22-8 mod_word internal static bit(9) initial dcl 22-8 mult internal static bit(9) initial dcl 22-8 ne internal static bit(9) initial dcl 15-3 negate internal static bit(9) initial dcl 22-8 ngt internal static bit(9) initial dcl 15-3 nlt internal static bit(9) initial dcl 15-3 no_token internal static bit(9) initial dcl 15-3 not internal static bit(9) initial dcl 15-3 not_bits internal static bit(9) initial dcl 22-8 not_equal internal static bit(9) initial dcl 22-8 off_fun internal static bit(9) initial dcl 22-8 offset_adder 000000 constant entry external dcl 1-172 offset_mask internal static bit(36) initial dcl 11-3 on_statement internal static bit(9) initial dcl 25-3 open_file internal static bit(9) initial dcl 22-8 open_statement internal static bit(9) initial dcl 25-3 operator_semantics 000000 constant entry external dcl 1-184 optimizer 000000 constant entry external dcl 2-361 or internal static bit(9) initial dcl 15-3 or_bits internal static bit(9) initial dcl 22-8 pack internal static bit(9) initial dcl 22-8 packed_digits_per_character internal static fixed bin(31,0) initial dcl 10-5 param_desc_ptr internal static bit(9) initial dcl 22-8 param_ptr internal static bit(9) initial dcl 22-8 parse_error 000000 constant entry external dcl 2-364 parse_error$no_text 000000 constant entry external dcl 2-368 percent internal static bit(9) initial dcl 15-3 period internal static bit(9) initial dcl 15-3 picture_char_type internal static fixed bin(8,0) initial packed unaligned dcl 8-20 picture_complexfix_type internal static fixed bin(8,0) initial packed unaligned dcl 8-20 picture_complexflo_type internal static fixed bin(8,0) initial packed unaligned dcl 8-20 picture_mask internal static bit(36) initial dcl 11-3 picture_realfix_type internal static fixed bin(8,0) initial packed unaligned dcl 8-20 picture_realflo_type internal static fixed bin(8,0) initial packed unaligned dcl 8-20 pl1_error_print$listing_segment 000000 constant entry external dcl 2-384 pl1_error_print$write_out 000000 constant entry external dcl 2-372 pl1_mod_fun internal static bit(9) initial dcl 22-8 pl1_print$for_lex 000000 constant entry external dcl 2-418 pl1_print$non_varying 000000 constant entry external dcl 2-398 pl1_print$non_varying_nl 000000 constant entry external dcl 2-402 pl1_print$string_pointer 000000 constant entry external dcl 2-406 pl1_print$string_pointer_nl 000000 constant entry external dcl 2-410 pl1_print$unaligned_nl 000000 constant entry external dcl 2-414 pl1_print$varying 000000 constant entry external dcl 2-392 pl1_print$varying_nl 000000 constant entry external dcl 2-395 plus internal static bit(9) initial dcl 15-3 precision_mask internal static bit(36) initial dcl 11-3 prefix_plus internal static bit(9) initial dcl 22-8 procedure_statement internal static bit(9) initial dcl 25-3 propagate_bit 000000 constant entry external dcl 1-192 ps_copy internal static fixed bin(15,0) initial dcl 26-3 ps_descriptor internal static fixed bin(15,0) initial dcl 26-3 ps_format_area internal static fixed bin(15,0) initial dcl 26-3 ps_job internal static fixed bin(15,0) initial dcl 26-3 ps_key internal static fixed bin(15,0) initial dcl 26-3 ps_label internal static fixed bin(15,0) initial dcl 26-3 ps_lock_sw internal static fixed bin(15,0) initial dcl 26-3 ps_number internal static fixed bin(15,0) initial dcl 26-3 ps_offset internal static fixed bin(15,0) initial dcl 26-3 ps_prep internal static fixed bin(15,0) initial dcl 26-3 ps_set_p internal static fixed bin(15,0) initial dcl 26-3 ps_source internal static fixed bin(15,0) initial dcl 26-3 ps_ssl internal static fixed bin(15,0) initial dcl 26-3 ps_stack internal static fixed bin(15,0) initial dcl 26-3 ps_symbol_block internal static fixed bin(15,0) initial dcl 26-3 ps_symbol_top internal static fixed bin(15,0) initial dcl 26-3 ps_value internal static fixed bin(15,0) initial dcl 26-3 ps_var_bitlen internal static fixed bin(15,0) initial dcl 26-3 ps_var_p internal static fixed bin(15,0) initial dcl 26-3 ptr_fun internal static bit(9) initial dcl 22-8 ptr_mask internal static bit(36) initial dcl 11-3 put_file internal static bit(9) initial dcl 22-8 put_list_trans internal static bit(9) initial dcl 22-8 put_statement internal static bit(9) initial dcl 25-3 put_string internal static bit(9) initial dcl 22-8 r_parn internal static bit(9) initial dcl 22-8 range_ck internal static bit(9) initial dcl 22-8 rank_fun internal static bit(9) initial dcl 22-8 read_file internal static bit(9) initial dcl 22-8 read_statement internal static bit(9) initial dcl 25-3 real_type internal static bit(36) initial dcl 10-71 record_io internal static bit(9) initial dcl 22-8 reducible_mask internal static bit(36) initial dcl 11-3 refer internal static bit(9) initial dcl 22-8 refer_extent 000000 constant entry external dcl 2-426 rel_fun internal static bit(9) initial dcl 22-8 repeat_fun internal static bit(9) initial dcl 22-8 reserve$clear 000000 constant entry external dcl 2-430 reserve$declare_lib 000000 constant entry external dcl 2-434 reserve$read_lib 000000 constant entry external dcl 2-439 return_bits internal static bit(9) initial dcl 22-8 return_statement internal static bit(9) initial dcl 25-3 return_string internal static bit(9) initial dcl 22-8 return_value internal static bit(9) initial dcl 22-8 return_words internal static bit(9) initial dcl 22-8 returns_mask internal static bit(36) initial dcl 11-3 reverse_fun internal static bit(9) initial dcl 22-8 revert_on internal static bit(9) initial dcl 22-8 revert_statement internal static bit(9) initial dcl 25-3 rewrite_file internal static bit(9) initial dcl 22-8 rewrite_statement internal static bit(9) initial dcl 25-3 right_parn internal static bit(9) initial dcl 15-3 round_fun internal static bit(9) initial dcl 22-8 search_fun internal static bit(9) initial dcl 22-8 search_rev_fun internal static bit(9) initial dcl 22-8 segno_fun internal static bit(9) initial dcl 22-8 semantic_translator 000000 constant entry external dcl 2-444 semantic_translator$call_es 000000 constant entry external dcl 1-196 semi_colon internal static bit(9) initial dcl 15-3 setbitno_fun internal static bit(9) initial dcl 22-8 setcharno_fun internal static bit(9) initial dcl 22-8 sf_par_node internal static bit(9) initial dcl 9-5 sign_fun internal static bit(9) initial dcl 22-8 signal_on internal static bit(9) initial dcl 22-8 signal_statement internal static bit(9) initial dcl 25-3 signed_mask internal static bit(36) initial dcl 11-3 simplify_expression 000000 constant entry external dcl 1-205 simplify_offset 000000 constant entry external dcl 1-212 sin_fun internal static bit(9) initial dcl 22-8 sind_fun internal static bit(9) initial dcl 22-8 slash internal static bit(9) initial dcl 15-3 source_node internal static bit(9) initial dcl 9-5 sqrt_fun internal static bit(9) initial dcl 22-8 stack_ptr internal static bit(9) initial dcl 22-8 stackbaseptr_fun internal static bit(9) initial dcl 22-8 stackframeptr_fun internal static bit(9) initial dcl 22-8 stacq_fun internal static bit(9) initial dcl 22-8 std_arg_list internal static bit(9) initial dcl 22-8 std_call internal static bit(9) initial dcl 22-8 std_entry internal static bit(9) initial dcl 22-8 std_return internal static bit(9) initial dcl 22-8 stop internal static bit(9) initial dcl 22-8 stop_statement internal static bit(9) initial dcl 25-3 storage_block_mask internal static bit(36) initial dcl 11-3 storage_block_type internal static bit(36) initial dcl 10-71 stream_prep internal static bit(9) initial dcl 22-8 string_mask internal static bit(36) initial dcl 11-41 structure_mask internal static bit(36) initial dcl 11-3 sub internal static bit(9) initial dcl 22-8 subscripter 000000 constant entry external dcl 1-216 symbol_node internal static bit(9) initial dcl 9-5 system_on_unit internal static bit(9) initial dcl 25-3 tan_fun internal static bit(9) initial dcl 22-8 tand_fun internal static bit(9) initial dcl 22-8 temporary_node internal static bit(9) initial dcl 9-5 terminate_trans internal static bit(9) initial dcl 22-8 this_context automatic bit(36) dcl 16-5 token_to_binary 000000 constant entry external dcl 2-459 translate_fun internal static bit(9) initial dcl 22-8 trunc_fun internal static bit(9) initial dcl 22-8 undesirable_mask internal static bit(36) initial dcl 11-41 unknown_statement internal static bit(9) initial dcl 25-3 unlock_file internal static bit(9) initial dcl 22-8 unlock_statement internal static bit(9) initial dcl 25-3 unpack internal static bit(9) initial dcl 22-8 unsigned_mask internal static bit(36) initial dcl 11-3 validate 000000 constant entry external dcl 1-225 variable_mask internal static bit(36) initial dcl 11-3 varying_mask internal static bit(36) initial dcl 11-3 vclock_fun internal static bit(9) initial dcl 22-8 verify_fun internal static bit(9) initial dcl 22-8 verify_ltrim_fun internal static bit(9) initial dcl 22-8 verify_rev_fun internal static bit(9) initial dcl 22-8 verify_rtrim_fun internal static bit(9) initial dcl 22-8 wait_statement internal static bit(9) initial dcl 25-3 word_to_mod2 internal static bit(9) initial dcl 22-8 word_to_mod4 internal static bit(9) initial dcl 22-8 word_to_mod8 internal static bit(9) initial dcl 22-8 wordno_fun internal static bit(9) initial dcl 22-8 words_per_condition_var internal static fixed bin(31,0) initial dcl 10-5 words_per_entry_var internal static fixed bin(31,0) initial dcl 10-5 words_per_file_var internal static fixed bin(31,0) initial dcl 10-5 words_per_fix_bin_1 internal static fixed bin(31,0) initial dcl 10-5 words_per_fix_bin_2 internal static fixed bin(31,0) initial dcl 10-5 words_per_flt_bin_1 internal static fixed bin(31,0) initial dcl 10-5 words_per_flt_bin_2 internal static fixed bin(31,0) initial dcl 10-5 words_per_format internal static fixed bin(31,0) initial dcl 10-5 words_per_label_var internal static fixed bin(31,0) initial dcl 10-5 words_per_offset internal static fixed bin(31,0) initial dcl 10-5 words_per_packed_pointer internal static fixed bin(31,0) initial dcl 10-5 words_per_pointer internal static fixed bin(31,0) initial dcl 10-5 words_per_varying_string_header internal static fixed bin(31,0) initial dcl 10-5 write_file internal static bit(9) initial dcl 22-8 write_statement internal static bit(9) initial dcl 25-3 xor_bits internal static bit(9) initial dcl 22-8 NAMES DECLARED BY EXPLICIT CONTEXT. c_form 002725 constant label dcl 703 ref 714 compare_format 006057 constant entry internal dcl 990 ref 201 convert_to_integer 002574 constant label dcl 680 ref 672 create_pic_ass_pf 005051 constant entry internal dcl 629 ref 602 605 612 down 005316 constant entry internal dcl 846 ref 859 edit_loop_ 000172 constant label dcl 78 ref 61 62 142 ef_null 005010 constant label dcl 619 ref 553 578 end_edit_loop_ 000645 constant label dcl 130 end_f_loop 002774 constant label dcl 726 ref 661 667 682 698 710 err170 002757 constant label dcl 721 ref 342 355 359 373 376 703 705 err171 002754 constant label dcl 717 ref 692 696 697 err427 003320 constant label dcl 1028 err469 003225 constant label dcl 802 ref 768 771 772 773 err470 003244 constant label dcl 812 ref 797 err495 003312 constant label dcl 1022 ref 182 194 err496 005030 constant label dcl 623 set ref 549 551 555 591 594 597 599 err497 003315 constant label dcl 1025 ref 977 exit 000171 constant label dcl 76 ref 137 827 exit_2 000663 constant label dcl 137 ref 412 expand_loop_set_ptr 003337 constant entry internal dcl 415 ref 197 267 432 f_list 002510 constant label dcl 665 ref 687 708 fail 006173 constant label dcl 1016 ref 1009 fl_process 002540 constant label dcl 675 force_cplx_temp 006176 constant entry internal dcl 1036 ref 362 format_list_process 003453 constant entry internal dcl 444 ref 134 477 484 format_list_semantics 002442 constant entry external dcl 652 full_symtab 003040 constant label dcl 745 ref 740 gdcommon 003153 constant label dcl 788 ref 769 gderr 003246 constant label dcl 814 ref 810 gdexit 003266 constant label dcl 820 ref 751 get_data_ 003004 constant label dcl 733 ref 59 get_next_format 006024 constant entry internal dcl 971 ref 166 200 216 269 get_next_part_of_cplx_format 006251 constant entry internal dcl 1049 ref 335 354 372 375 idl_err 003322 constant label dcl 1030 ref 1024 1027 int 002527 constant label dcl 672 ref 711 715 io_data_list_semantics 000075 constant entry external dcl 11 io_join_semantics 005512 constant entry internal dcl 887 ref 74 127 956 join_finish 006023 constant label dcl 967 ref 895 939 949 964 join_loop 005533 constant label dcl 898 ref 965 label_of_statement 005376 constant entry internal dcl 872 ref 959 lengths_set 001476 constant label dcl 295 ref 289 make_quick_puts 000676 constant label dcl 148 ref 135 new_join 005620 constant label dcl 919 ref 906 next_format 000763 constant label dcl 166 ref 173 next_format_this_data_item 001125 constant label dcl 216 set ref 241 ok 003261 constant label dcl 817 ref 800 pef_format 004074 constant entry internal dcl 532 ref 322 342 355 359 373 376 process_do 005734 constant label dcl 949 ref 926 934 punt 000663 constant label dcl 137 ref 172 187 189 201 420 423 432 458 461 492 496 498 501 507 509 518 sig_format_err 002761 constant label dcl 723 ref 719 walk 005256 constant entry internal dcl 832 ref 796 NAMES DECLARED BY CONTEXT OR IMPLICATION. addr builtin function ref 692 792 copy builtin function ref 558 560 560 602 602 602 605 605 min builtin function ref 570 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 7036 7126 6452 7046 Length 10106 6452 70 743 364 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME io_data_list_semantics 766 external procedure is an external procedure. expand_loop_set_ptr 84 internal procedure calls itself recursively. format_list_process 128 internal procedure calls itself recursively. pef_format internal procedure shares stack frame of external procedure io_data_list_semantics. create_pic_ass_pf internal procedure shares stack frame of external procedure io_data_list_semantics. walk 72 internal procedure calls itself recursively. label_of_statement internal procedure shares stack frame of internal procedure io_join_semantics. io_join_semantics 134 internal procedure calls itself recursively. get_next_format internal procedure shares stack frame of external procedure io_data_list_semantics. compare_format internal procedure shares stack frame of external procedure io_data_list_semantics. force_cplx_temp internal procedure shares stack frame of external procedure io_data_list_semantics. get_next_part_of_cplx_format internal procedure shares stack frame of external procedure io_data_list_semantics. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME expand_loop_set_ptr 000100 op_ptr expand_loop_set_ptr format_list_process 000100 h format_list_process 000101 iteration_factor format_list_process 000102 i format_list_process 000103 j format_list_process 000104 p format_list_process 000106 q format_list_process io_data_list_semantics 000100 trans_op io_data_list_semantics 000101 format_op io_data_list_semantics 000102 decode_complex_fun io_data_list_semantics 000104 p_str io_data_list_semantics 000205 prefix io_data_list_semantics 000206 p io_data_list_semantics 000210 q io_data_list_semantics 000212 r io_data_list_semantics 000214 s io_data_list_semantics 000216 tt io_data_list_semantics 000220 tp io_data_list_semantics 000222 jp io_data_list_semantics 000224 op io_data_list_semantics 000226 bx io_data_list_semantics 000230 vp io_data_list_semantics 000232 pa_ptr io_data_list_semantics 000234 rr io_data_list_semantics 000236 pp io_data_list_semantics 000240 wp io_data_list_semantics 000242 vs io_data_list_semantics 000244 uncomplex_temp io_data_list_semantics 000246 format_ptr io_data_list_semantics 000250 length_ptr io_data_list_semantics 000252 ip io_data_list_semantics 000254 c_format_ptr io_data_list_semantics 000256 q2 io_data_list_semantics 000260 loop_ptr io_data_list_semantics 000262 ctl_pointer io_data_list_semantics 000362 format_list_ptr_table io_data_list_semantics 000562 nss io_data_list_semantics 000564 ri io_data_list_semantics 000566 sy io_data_list_semantics 000570 i io_data_list_semantics 000571 j io_data_list_semantics 000572 ki io_data_list_semantics 000573 k io_data_list_semantics 000574 n io_data_list_semantics 000575 constant_operands io_data_list_semantics 000576 pti io_data_list_semantics 000577 ctli io_data_list_semantics 000600 wi io_data_list_semantics 000601 si io_data_list_semantics 000602 de io_data_list_semantics 000603 pa_opnum io_data_list_semantics 000604 peti io_data_list_semantics 000605 first_peti io_data_list_semantics 000606 op_num io_data_list_semantics 000607 var_cnt io_data_list_semantics 000610 num_eaten io_data_list_semantics 000611 data_item_index io_data_list_semantics 000612 cur_rep io_data_list_semantics 000613 ctl_cnt io_data_list_semantics 000614 c_length io_data_list_semantics 000615 get_of_noncomputational io_data_list_semantics 000616 data_format_found io_data_list_semantics 000617 no_quick_edit io_data_list_semantics 000620 flt io_data_list_semantics 000622 fltt io_data_list_semantics 000624 fop io_data_list_semantics 000625 pa_type io_data_list_semantics 000626 context io_data_list_semantics 000664 vp pef_format 000674 p create_pic_ass_pf 000676 q create_pic_ass_pf 000714 a compare_format 000716 b compare_format 000720 i compare_format 000746 q force_cplx_temp io_join_semantics 000106 r label_of_statement 000110 randi io_join_semantics 000112 s io_join_semantics 000114 op io_join_semantics 000116 q io_join_semantics 000120 tt io_join_semantics 000122 i io_join_semantics 000123 j io_join_semantics 000124 k io_join_semantics 000125 l io_join_semantics 000126 m io_join_semantics 000127 n io_join_semantics walk 000100 tp walk THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 signal_op shorten_stack ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. compare_expression convert$from_builtin convert$to_target convert$to_target_fb copy_expression copy_unique_expression create_label create_list create_operator create_statement create_symbol create_token declare declare_constant$integer declare_picture_temp declare_temporary defined_reference expression_semantics io_data_list_semantics$format_list_semantics make_non_quick semantic_translator$abort semantic_translator$error share_expression THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. pl1_stat_$ok_list LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 23 000055 43 000066 11 000071 52 000103 53 000107 54 000113 55 000116 56 000120 57 000124 59 000126 61 000130 62 000132 64 000134 67 000144 68 000147 69 000154 70 000157 71 000161 73 000162 74 000163 76 000171 78 000172 86 000216 88 000225 89 000245 95 000262 96 000264 98 000273 99 000276 100 000302 101 000304 102 000327 105 000335 107 000342 108 000363 109 000404 110 000422 112 000432 113 000453 114 000463 115 000504 116 000532 117 000556 118 000563 119 000603 120 000610 121 000612 122 000615 123 000624 127 000637 130 000645 133 000653 134 000654 135 000662 137 000663 140 000671 141 000673 142 000675 148 000676 152 000677 154 000731 156 000735 158 000747 160 000751 161 000752 162 000753 163 000754 164 000755 166 000763 168 000764 171 000772 172 000773 173 000776 176 000777 177 001001 178 001002 180 001013 182 001015 185 001021 187 001026 189 001030 194 001032 197 001034 198 001051 199 001053 200 001063 201 001064 206 001106 210 001110 211 001112 212 001113 213 001114 214 001115 216 001125 219 001126 220 001132 222 001140 224 001145 226 001152 228 001157 230 001164 232 001165 234 001167 235 001204 236 001222 238 001245 239 001263 240 001264 241 001266 246 001267 247 001276 248 001301 250 001306 251 001310 252 001312 253 001314 254 001316 256 001317 257 001321 258 001324 261 001326 263 001333 264 001336 265 001340 267 001341 268 001357 269 001367 270 001370 273 001372 277 001377 279 001404 280 001417 282 001434 284 001437 287 001453 288 001456 289 001460 293 001461 294 001462 295 001476 298 001534 299 001535 301 001553 303 001564 305 001566 308 001601 309 001613 311 001616 312 001633 314 001660 315 001677 316 001700 318 001717 319 001732 320 001735 322 001736 324 001743 326 001754 327 001757 328 001761 329 001776 331 002002 334 002043 335 002051 336 002055 337 002073 338 002075 339 002100 341 002106 342 002122 344 002127 345 002132 346 002134 348 002135 354 002145 355 002151 358 002161 359 002162 361 002200 362 002205 363 002216 364 002234 365 002236 366 002241 367 002245 368 002250 369 002253 372 002256 373 002262 374 002267 375 002272 376 002276 377 002326 382 002331 385 002333 387 002335 388 002352 389 002361 390 002364 391 002366 394 002377 395 002402 397 002406 398 002410 399 002411 400 002412 402 002416 403 002421 406 002423 408 002432 410 002435 412 002437 652 002440 654 002450 655 002455 657 002457 659 002464 660 002475 661 002501 663 002505 665 002510 667 002524 670 002525 672 002527 675 002540 677 002541 678 002561 680 002574 682 002631 685 002632 687 002634 688 002637 690 002641 691 002642 692 002661 693 002664 694 002677 695 002707 696 002711 697 002715 698 002722 701 002723 703 002725 705 002731 708 002742 710 002743 711 002745 714 002746 715 002753 717 002754 719 002756 721 002757 723 002761 726 002774 728 003001 730 003003 733 003004 739 003010 740 003032 742 003033 743 003037 745 003040 747 003044 748 003050 749 003053 750 003055 751 003056 754 003057 763 003065 764 003067 766 003074 767 003075 768 003115 769 003121 771 003122 772 003124 773 003127 774 003132 775 003133 788 003153 792 003156 796 003214 797 003222 800 003224 802 003225 804 003227 806 003233 807 003235 808 003237 809 003240 810 003243 812 003244 814 003246 816 003257 817 003261 819 003264 820 003266 822 003301 823 003306 824 003307 827 003311 1022 003312 1024 003314 1025 003315 1027 003317 1028 003320 1030 003322 1089 003335 415 003336 419 003344 420 003350 423 003361 425 003372 427 003403 428 003406 429 003410 432 003415 444 003452 448 003460 450 003470 453 003506 455 003514 457 003517 458 003525 461 003542 463 003552 465 003554 467 003566 468 003570 470 003576 471 003602 476 003640 477 003647 478 003656 479 003660 480 003661 482 003663 483 003665 484 003675 485 003704 486 003706 489 003707 492 003711 494 003722 496 003731 497 003741 498 003754 501 003774 503 004004 505 004007 506 004011 507 004012 509 004017 518 004047 519 004056 520 004060 521 004065 524 004067 525 004073 532 004074 536 004076 538 004101 541 004104 543 004116 544 004117 546 004131 547 004132 549 004140 551 004142 553 004144 555 004145 558 004152 560 004202 562 004250 564 004266 565 004333 566 004354 567 004372 570 004410 571 004434 574 004440 577 004442 578 004450 579 004451 582 004463 583 004503 585 004512 587 004517 589 004531 591 004534 594 004540 596 004544 597 004545 599 004550 602 004554 605 004665 606 004743 608 004750 610 004752 611 004756 612 004771 615 005002 617 005006 619 005010 621 005024 623 005030 625 005032 626 005045 629 005051 636 005053 637 005117 639 005124 640 005141 641 005161 642 005176 644 005177 645 005214 648 005233 649 005252 832 005255 835 005263 837 005265 838 005272 839 005276 841 005303 843 005311 844 005313 846 005314 848 005323 850 005332 851 005334 853 005342 854 005344 858 005356 859 005362 860 005371 861 005374 862 005375 872 005376 876 005400 877 005427 879 005436 880 005457 881 005464 882 005504 883 005507 887 005511 894 005517 895 005521 896 005526 898 005533 900 005543 901 005547 904 005560 905 005563 906 005566 908 005567 909 005605 915 005610 916 005614 917 005616 919 005620 926 005623 928 005624 929 005652 931 005655 933 005660 934 005665 936 005666 938 005670 939 005674 942 005675 945 005714 946 005723 947 005732 949 005734 952 005737 953 005765 954 005770 955 005772 956 005774 959 006003 960 006010 961 006013 963 006015 964 006020 965 006022 967 006023 971 006024 973 006025 974 006030 975 006031 977 006034 978 006036 980 006040 981 006043 983 006044 985 006046 986 006052 988 006056 990 006057 998 006061 999 006064 1001 006067 1003 006076 1008 006130 1009 006137 1012 006165 1013 006167 1016 006173 1036 006176 1040 006200 1041 006203 1049 006251 1052 006253 1055 006261 1056 006264 1057 006270 1058 006300 1060 006303 ----------------------------------------------------------- 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