COMPILATION LISTING OF SEGMENT probe_invoke_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 11/11/88 1550.5 mst Fri Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 /* format: style1,insnl,ifthendo,indthenelse,^indnoniterdo,^inditerdo,indcom,^indthenbegin,^indprocbody,ind2,ll78,initcol0,dclind4,idind24,struclvlind1,comcol41 */ 13 14 /**** * * * * * * * * * * * * * * * * * * * * * * * */ 15 16 /****^ HISTORY COMMENTS: 17* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 18* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1212): 19* Fixed bug in passing file parameters when calling a PASCAL procedure. 20* 2) change(88-09-07,WAAnderson), approve(88-09-30,MCR7952), 21* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 22* Added format control comment to make the source more readable. 23* END HISTORY COMMENTS */ 24 25 probe_invoke_: 26 proc (); 27 28 call probe_error_$malfunction (); /* dummy entry */ 29 30 /* This procedure is used to invoke functions and call subroutines. The arguments supplied 31* will be converted to the expected type if entry argument descriptors are available for 32* the called entry. 33* 34* Initial Version: 10 August 1974 by Jeffrey M. Broughton 35* Modified: 4 December 1978 by James R. Davis to not clobber generation ptr 36* Modified: 12 December 1978 by JRD to call assign_value instead of assign_reference 37* Modified: 10 March 1980 by JRD to call probe_assign_value_ 38* Note: this program could be cleaned up a fair bit, and ought to be, someday */ 39 /* Made to call Pascal programs 09/14/83 J.M.Athane */ 40 /* Added version strings to runtime_symbol_info_ structures 10/06/83 S. Herbst */ 41 /* Fixed to call gates 02/10/84 S. Herbst */ 42 /* Fixed bug in passing file parameters in Pascal JMAthane June 85 */ 43 44 dcl ( 45 P_probe_info_ptr pointer, 46 P_code fixed bin (35) 47 ) parameter; 48 49 dcl 1 P_entry_ref aligned like reference_node parameter; 50 /* description of procedure to call */ 51 dcl 1 P_return_ref aligned like reference_node parameter; 52 /* place to put return value */ 53 54 dcl FB24_ALL_ONES fixed bin (24) int static 55 options (constant) 56 init (111111111111111111111111b); 57 58 dcl function_flag bit (1); /* flags the entry used */ 59 dcl number_args fixed bin;/* number of arguments supplied */ 60 dcl possible_number fixed bin;/* number including return arg */ 61 dcl entry pointer; /* to procedure to be called */ 62 dcl stack_frame pointer; /* display pointer of proc (if any) */ 63 dcl code fixed bin (35); 64 /* global error code */ 65 66 dcl 1 arg_ref_list aligned based, 67 /* list of arguments to procedure */ 68 2 number fixed bin,/* how many */ 69 2 node (0 refer (arg_ref_list.number)) pointer; 70 /* to reference nodes of args */ 71 72 dcl 1 encoded aligned based, 73 /* overlay for encoded scale and precision */ 74 2 scale fixed bin (17) unaligned, 75 2 precision fixed bin (17) unaligned; 76 77 dcl 1 entry_var aligned based, 78 /* overlay for entry variable */ 79 2 place pointer, 80 2 frame pointer; 81 82 dcl type_size (23) fixed bin internal static 83 options (constant) 84 initial /* storage needed for converted args */ 85 (1, 2, 1, 2, 2, 4, 2, 4, 30, 32, 60, 64, 86 2, 1, 4, 4, 0, 0, -36, -36, -4, -4, 2); 87 88 dcl ( 89 error_table_$lower_ring, 90 error_table_$nodescr, /* code for no desciptors */ 91 probe_et_$array_arg, 92 probe_et_$bad_return_val, 93 probe_et_$int_proc, 94 probe_et_$no_return_desc, 95 probe_et_$not_function, 96 probe_et_$recorded_message, 97 probe_et_$struc_arg, 98 probe_et_$wrong_no_args 99 ) fixed bin (35) external static; 100 101 dcl probe_assign_value_ entry (ptr, 102 1 structure aligned like reference_node, 103 1 structure aligned like reference_node, 104 fixed bin (35)); 105 106 dcl probe_error_$record entry options (variable); 107 dcl probe_error_$malfunction 108 entry options (variable); 109 110 dcl cu_$gen_call entry (pointer, pointer); 111 dcl cu_$grow_stack_frame entry (fixed bin (18), ptr, fixed bin (35)); 112 dcl decode_descriptor_ entry (pointer, fixed bin, fixed bin, bit (1), 113 fixed bin, fixed bin, fixed bin); 114 dcl get_entry_arg_descs_ entry (pointer, fixed bin, 115 pointer dimension (*), fixed bin (35)); 116 117 dcl (addr, addrel, bit, ceil, divide, fixed, min, null, reverse, substr, 118 unspec, verify) builtin; 119 120 121 probe_invoke_$function: 122 entry (P_probe_info_ptr, P_entry_ref, P_return_ref, P_code); 123 124 function_flag = "1"b; /* there will be a return argument */ 125 go to common; 126 127 128 probe_invoke_$subroutine: 129 entry (P_probe_info_ptr, P_entry_ref, P_code); 130 131 function_flag = "0"b; /* no return arg, just call the procedure */ 132 go to common; 133 134 common: 135 probe_info_ptr = P_probe_info_ptr; 136 137 138 /* Get the number of arguments expected, and find out what procedure to call */ 139 140 number_args = P_entry_ref.argument_list -> arg_ref_list.number; 141 /* user gave arguments */ 142 possible_number = number_args + fixed (function_flag, 1, 0); 143 /* if function then there may be one more */ 144 145 if P_entry_ref.type_ptr = null 146 then 147 begin; /* no PASCAL procedure description available */ 148 if P_entry_ref.type = 16 149 then do; /* invoking an entry variable */ 150 entry = P_entry_ref.address_ptr -> entry_var.place; 151 /* get real entry */ 152 stack_frame = P_entry_ref.address_ptr -> entry_var.frame; 153 end; 154 else if P_entry_ref.type = 25 155 then /* it is an interanl proc */ 156 stack_frame = addr (stack_frame); 157 /* int procs not supported, flag as such */ 158 else do; 159 entry = P_entry_ref.address_ptr;/* external entry */ 160 stack_frame = null; 161 end; 162 163 if stack_frame ^= null then do; /* check for calling an internal proc */ 164 call probe_error_$record (probe_info_ptr, probe_et_$int_proc, 165 P_entry_ref.name); 166 goto RECORDED_MESSAGE; 167 end; 168 169 170 171 begin; 172 173 /* When this block is entered, space for the argument list and descriptors will be allocated */ 174 175 declare 176 177 desc_ptrs (possible_number) pointer, 178 /* argument descriptors from called proc */ 179 1 dummy_arg_list aligned, 180 /* argument list storage */ 181 2 align_arg_list pointer, 182 /* kludge to double word align arglist */ 183 2 arg_list, /* here is the real one */ 184 3 arg_count fixed bin (17) unaligned, 185 /* number of arguments */ 186 3 call_code fixed bin (17) unaligned initial (4), 187 /* this is a pl1 call */ 188 3 desc_count fixed bin (17) unaligned, 189 /* number of descriptors */ 190 3 info (possible_number * 2) pointer, 191 /* place to pu arg and descriptor ptrs */ 192 desc_origin fixed bin, 193 /* index of first desc ptr in info */ 194 number_descs fixed bin, 195 /* number of descriptors from proc to be called */ 196 type fixed bin, 197 /* attributes from descriptors */ 198 ndims fixed bin, 199 size fixed bin, 200 scale fixed bin, 201 packed bit (1), 202 match bit (1), 203 /* proc has entry descrs, match called args to them */ 204 must_build bit (1), 205 /* indicates that we must build a descriptor */ 206 207 1 argument aligned like reference_node 208 based (arg_ref), 209 /* reference node for argument */ 210 arg_ref pointer, 211 i fixed bin; 212 213 214 /* See if the called procedure has argument descriptors, if it does we will try 215* to match the arguments given to the types desired, otherwise, descriptors for 216* the arguments supplied will built, and the call made blindly */ 217 218 call get_entry_arg_descs_ (entry, number_descs, desc_ptrs, code); 219 /* find the descriptors (if any) */ 220 if code ^= 0 221 then if code = error_table_$nodescr | code = error_table_$lower_ring 222 then match = "0"b; /* problem is tolerable */ 223 else do; 224 call probe_error_$record (probe_info_ptr, code, "^a", 225 P_entry_ref.name); 226 goto RECORDED_MESSAGE; 227 end; 228 229 else match = "1"b; 230 231 232 if match 233 234 then do; /* try to match given and expected types */ 235 236 if possible_number = number_descs 237 then do; /* then things are fine */ 238 arg_list.arg_count = possible_number * 2; 239 /* complete arg list header */ 240 arg_list.desc_count = possible_number * 2; 241 desc_origin = possible_number; 242 end; 243 else if function_flag & (number_args = number_descs) then do; 244 call probe_error_$record (probe_info_ptr, 245 probe_et_$not_function, P_entry_ref.name); 246 goto RECORDED_MESSAGE; 247 end; 248 249 else do; 250 call probe_error_$record (probe_info_ptr, 251 probe_et_$wrong_no_args, P_entry_ref.name); 252 goto RECORDED_MESSAGE; /* some other problem */ 253 end; 254 255 256 do i = 1 to number_args; /* match each argument */ 257 arg_ref = P_entry_ref.argument_list -> arg_ref_list.node (i); 258 if argument.type = structure_dtype then do; 259 call probe_error_$record (probe_info_ptr, 260 probe_et_$struc_arg, argument.name); 261 goto RECORDED_MESSAGE; 262 end; 263 264 call decode_descriptor_ (desc_ptrs (i), 0, type, packed, ndims, 265 size, scale); 266 267 if ndims > 0 then do; 268 code = probe_et_$array_arg; 269 goto SOME_ERROR; 270 end; 271 272 else if argument.type ^= type 273 /* argument types do not match */ 274 then call match_arg (arg_ref, type, size, scale, packed); 275 else if size ^= addr (argument.precision) -> encoded.precision 276 then do; 277 if size = FB24_ALL_ONES 278 /* "*" extent */ 279 then ; /* just have to make a descriptor */ 280 else call match_arg (arg_ref, type, size, scale, packed); 281 end; 282 else if scale ^= addr (argument.precision) -> encoded.scale 283 then call match_arg (arg_ref, type, size, scale, packed); 284 else if packed ^= argument.packed 285 then call match_arg (arg_ref, type, size, scale, packed); 286 287 must_build = (size = FB24_ALL_ONES); 288 if must_build 289 then info (desc_origin + i) = build_descriptor (arg_ref); 290 else info (desc_origin + i) = desc_ptrs (i); 291 info (i) = argument.address_ptr; 292 if type = 20 | type = 22 293 then /* for varying length strings, the pointer to */ 294 info (i) = addrel (info (i), 1); 295 /* arg must pt to string itself, not length word. */ 296 297 end; 298 299 if function_flag then do; /* create entry for return argument */ 300 call decode_descriptor_ (desc_ptrs (number_descs), 0, type, 301 packed, ndims, size, scale); 302 if ndims ^= 0 | size = FB24_ALL_ONES then do; 303 call probe_error_$record (probe_info_ptr, 304 probe_et_$bad_return_val, P_entry_ref.name); 305 goto RECORDED_MESSAGE; 306 end; 307 308 P_return_ref.name = P_entry_ref.name || " [return val]"; 309 P_return_ref.type = type; 310 P_return_ref.descriptor = type * 2 + fixed (packed, 1, 0); 311 P_return_ref.precision = size; 312 addr (P_return_ref.precision) -> encoded.scale = scale; 313 P_return_ref.flags = "0"b; 314 P_return_ref.constant = "1"b; 315 P_return_ref.packed = packed; 316 P_return_ref.symbol_ptr = null; 317 if P_return_ref.source_info_ptr ^= null 318 then P_return_ref.source_info_ptr -> source_info.block_ptr, 319 P_return_ref.source_info_ptr 320 -> source_info.stack_ptr, 321 P_return_ref.source_info_ptr 322 -> source_info.entry_ptr = null (); 323 i = type_size (type); /* allocate storage for result */ 324 if i < 0 /* char or bit, figure out no of words */ 325 then i = divide (size - i, -i, 17, 0); 326 P_return_ref.address_ptr = allocate_temp (i); 327 328 info (number_descs) = P_return_ref.address_ptr; 329 if type = 20 | type = 22 330 then /* kludge ptr to varying strings to point */ 331 /* beyond length word to start of string */ 332 info (number_descs) = addrel (info (number_descs), 1); 333 info (desc_origin + number_descs) = desc_ptrs (number_descs); 334 end; 335 336 end; /* of match code */ 337 338 else do; /* nothing to compare with, work blindly */ 339 if function_flag then do; /* no idea of what the return arg is */ 340 call probe_error_$record (probe_info_ptr, 341 probe_et_$no_return_desc, P_entry_ref.name); 342 goto RECORDED_MESSAGE; 343 end; 344 345 arg_list.arg_count = possible_number * 2; 346 /* build argument list header */ 347 arg_list.desc_count = possible_number * 2; 348 desc_origin = possible_number; 349 350 do i = 1 to number_args; /* build descriptors for all args */ 351 arg_ref = P_entry_ref.argument_list -> arg_ref_list.node (i); 352 info (i) = argument.address_ptr; 353 if argument.type = 20 | argument.type = 22 354 then 355 info (i) = addrel (info (i), 1); 356 info (desc_origin + i) = build_descriptor (arg_ref); 357 end; 358 359 end; 360 361 362 /* Ta Da !!!!!!!! */ 363 364 call cu_$gen_call (entry, addr (arg_list)); 365 /* make the call */ 366 367 match_arg: 368 procedure (ref, type, precision, scale, packed); 369 370 371 declare 372 373 ref pointer, 374 /* to reference node of argument, altered 375* on return to node of matched temporary */ 376 type fixed bin, 377 /* desired data type */ 378 precision fixed bin, 379 /* arithmetic precsion or size */ 380 scale fixed bin, 381 packed bit (1), 382 383 1 argument aligned like reference_node based (ref), 384 /* input argument */ 385 1 temp aligned like reference_node based (tref), 386 /* converted argument temporary */ 387 tref pointer, 388 389 based_string character (128) based, 390 need fixed bin, 391 /* storage for temporary */ 392 i fixed bin, 393 arith_to_char bit (1) initial ("0"b), 394 /* convert arith to char(*) */ 395 size builtin; 396 397 398 tref = allocate_temp (size (temp)); /* make a place for it */ 399 400 temp.symbol_ptr, temp.source_info_ptr = null; 401 temp.name = "argument temporary"; 402 403 temp.type = type; /* fill in data and perform conversion */ 404 temp.descriptor = type * 2 + fixed (packed, 1, 0); 405 temp.precision = precision; 406 addr (temp.precision) -> encoded.scale = scale; 407 408 if precision = FB24_ALL_ONES /* encoded size - target must be bit, char, or area */ 409 then if argument.type > 12 /* source val also char bit or area */ 410 then temp.precision = precision; 411 /* is the same for char to char, bit to bit, etc. */ 412 else if type >= 21 /* target is char */ 413 then do; 414 temp.precision = 128; /* target will have room to hold any arithmetic */ 415 arith_to_char = "1"b; /* will truncate trailing blanks later */ 416 end; 417 else do; /* target is bit */ 418 i = addr (argument.precision) -> encoded.precision 419 - addr (argument.precision) -> encoded.scale; 420 if i < 0 421 then i = 0; /* compute size of result */ 422 if argument.type > 8 423 then i = ceil (i * 3.32); /* decimal, result is psuedo-binary */ 424 i = min (71, i); 425 temp.precision = i; 426 end; 427 428 temp.flags = "0"b; 429 temp.packed = packed; 430 431 need = type_size (type); /* make a place to put temporary */ 432 if need < 0 433 then need = divide (temp.precision - need - 1, -need, 17, 0); 434 temp.address_ptr = allocate_temp (need); 435 436 call probe_assign_value_ (probe_info_ptr, temp, argument, code); 437 /* convert the two */ 438 if code ^= 0 439 then goto SOME_ERROR; 440 441 if arith_to_char then do; 442 i = verify (reverse (temp.address_ptr -> based_string), " "); 443 temp.precision = 129 - i; 444 end; 445 ref = tref; 446 return; 447 end match_arg; 448 449 build_descriptor: 450 procedure (ref) returns (pointer); 451 452 453 declare 454 455 ref pointer, 456 /* to argument's reference node */ 457 1 argument aligned like reference_node based (ref), 458 459 1 descriptor aligned based (dp), 460 /* template descriptor */ 461 2 flag bit (1) unaligned, 462 /* indicates new format */ 463 2 type bit (6) unaligned, 464 /* data type */ 465 2 packed bit (1) unaligned, 466 /* unaligned types */ 467 2 ndims bit (4) unaligned, 468 /* number of dimensions */ 469 2 size bit (24) unaligned, 470 /* arithmetic precision and scale, other size */ 471 dp pointer, 472 size builtin; 473 474 if argument.type = 17 then do; 475 call probe_error_$record (probe_info_ptr, probe_et_$struc_arg, 476 argument.name); 477 goto RECORDED_MESSAGE; 478 end; 479 dp = allocate_temp (size (descriptor)); 480 /* make a palce for it */ 481 482 descriptor.flag = "1"b; /* and fill in information */ 483 descriptor.type = bit (fixed (argument.type, 6, 0)); 484 descriptor.packed = argument.packed; 485 descriptor.ndims = (4)"0"b; 486 487 if argument.type > 12 /* non-arithmetic, no scale */ 488 then descriptor.size = bit (fixed (argument.precision, 24, 0)); 489 else do; 490 substr (descriptor.size, 1, 12) = 491 bit (fixed (addr (argument.precision) -> encoded.scale, 12, 0)); 492 substr (descriptor.size, 13, 12) = 493 bit (fixed (addr (argument.precision) -> encoded.precision, 12, 0)) 494 ; 495 end; 496 497 return (dp); 498 499 500 end build_descriptor; 501 502 503 allocate_temp: 504 procedure (words_needed) returns (pointer); 505 506 /* This routine allocates temporary storage in the stack frame of its caller. Its function depends on 507* its being W a quick block. And that the storage be needed only for the length of time that the 508* procedure is active. */ 509 510 dcl words_needed fixed bin parameter; 511 dcl p pointer; 512 513 call cu_$grow_stack_frame ((words_needed), p, code); 514 if code ^= 0 515 then goto SOME_ERROR; /* lossage */ 516 return (p); 517 end; /* allocate_temp internal procedure */ 518 519 end; /* of main procedure begin block */ 520 end; /* non PASCAL typed procedure */ 521 522 else 523 begin; /* call a la PASCAL : all proc and params supported ! */ 524 525 /* for argument checking, we will use the formal parameters list 526* which describes how the procedure was declared in the current program. */ 527 528 dcl 1 dummy_arg_list, 529 2 align ptr, 530 2 arg_list, 531 3 arg_count fixed bin (17) unal 532 init (possible_number * 2), 533 3 call_code fixed bin (17) unal init (4), 534 3 desc_count fixed bin (17) unal init (0), 535 3 info (possible_number * 2) ptr; 536 537 dcl (f_dims, a_dims) fixed bin (35); 538 dcl pascal_int_call_op fixed bin (35) init (42); 539 dcl pascal_ext_call_op fixed bin (35) init (43); 540 dcl pascal_return_value fixed bin (35) based; 541 dcl pascal_entry_parm_size fixed bin init (5); 542 dcl pvalue_ref_ptr ptr; 543 dcl formal_ptr ptr; 544 dcl pascal_gen_call_ entry (ptr, ptr, ptr, fixed bin (35), 545 fixed bin (35)); 546 dcl operator_number fixed bin (35); 547 dcl 1 argument like reference_node 548 based (arg_ref_ptr) aligned; 549 dcl 1 entry_type_info like runtime_type_info; 550 dcl 1 fconf_type_info like runtime_type_info; 551 dcl arg_ref_ptr ptr; 552 dcl bit_size fixed bin (35); 553 dcl bit_string bit (bit_size) unal based; 554 dcl temp_addr ptr; 555 dcl get_size_in_bits_ entry (fixed bin, fixed bin (35), 556 bit (1) aligned) returns (fixed bin); 557 dcl (i, total_dims) fixed bin (35); 558 dcl (formal_is_conformant, arg_is_conformant) 559 bit (1); 560 dcl 1 formal_type_info like runtime_type_info; 561 dcl 1 arg_type_info like runtime_type_info; 562 dcl 1 pvalue_ref like reference_node 563 based (pvalue_ref_ptr) aligned; 564 dcl 1 formal_array_info like runtime_array_info; 565 dcl 1 arg_array_info like runtime_array_info; 566 dcl 1 pascal_entry_parm based, 567 2 place ptr, 568 2 frame ptr, 569 2 op_nbr fixed bin (35); 570 dcl probe_pascal_$real_type entry (fixed bin (35), ptr, fixed bin (35), 571 ptr); 572 dcl probe_create_reference_ entry (ptr, ptr); 573 dcl (Block_ptr, Linkage_ptr, Stack_ptr, Base_addr) 574 ptr; 575 dcl based_ptr ptr based; 576 577 if P_entry_ref.type = pascal_parameter_procedure_dtype then do; 578 entry = P_entry_ref.address_ptr -> pascal_entry_parm.place; 579 stack_frame = P_entry_ref.address_ptr -> pascal_entry_parm.frame; 580 operator_number = 581 P_entry_ref.address_ptr -> pascal_entry_parm.op_nbr; 582 end; 583 else if P_entry_ref.type = pascal_internal_procedure_dtype then do; 584 entry = P_entry_ref.address_ptr; 585 stack_frame = P_entry_ref.source_info_ptr -> source_info.stack_ptr; 586 operator_number = pascal_int_call_op; 587 end; 588 else if (P_entry_ref.type = pascal_imported_procedure_dtype) | 589 (P_entry_ref.type = pascal_exportable_procedure_dtype) then do; 590 entry = P_entry_ref.address_ptr; 591 stack_frame = null; 592 operator_number = pascal_ext_call_op; 593 end; 594 595 formal_ptr = runtime_symbol_info_$son (P_entry_ref.type_ptr); 596 597 do i = 1 to number_args; 598 if formal_ptr = null then do; 599 wrong_no_arg_err: 600 call probe_error_$record (probe_info_ptr, probe_et_$wrong_no_args, 601 P_entry_ref.name); 602 go to RECORDED_MESSAGE; 603 end; 604 arg_ref_ptr = P_entry_ref.argument_list -> arg_ref_list.node (i); 605 Block_ptr = argument.source_info_ptr -> source_info.block_ptr; 606 Stack_ptr = argument.source_info_ptr -> source_info.stack_ptr; 607 Linkage_ptr = 608 argument.source_info_ptr -> source_info.seg_info_ptr 609 -> seg_info.linkage_ptr; 610 Base_addr = argument.base_addr; 611 612 formal_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 613 614 call runtime_symbol_info_$type (formal_ptr, addr (formal_type_info), 615 code); 616 if code ^= 0 617 then go to SOME_ERROR; 618 619 formal_is_conformant = 620 is_conformant (formal_type_info.base_type_addr, f_dims, 621 formal_array_info); 622 if argument.type_ptr = null 623 then arg_is_conformant = "0"b; 624 else arg_is_conformant = 625 is_conformant (argument.type_ptr, a_dims, arg_array_info); 626 if formal_type_info.type = pascal_variable_formal_parameter_dtype 627 then do; 628 /* passed by address. Types must match. Constants not allowed */ 629 if (argument.symbol_ptr = null) 630 | (argument.name = "<>") then do; 631 invalid_arg_err: 632 call probe_error_$record (probe_info_ptr, 0, 633 "Argument ^d passed to ^a is invalid.", i, 634 P_entry_ref.name); 635 go to RECORDED_MESSAGE; 636 end; 637 else do; 638 639 arg_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 640 641 call runtime_symbol_info_$type (argument.symbol_ptr, 642 addr (arg_type_info), code); 643 if code ^= 0 644 then go to SOME_ERROR; 645 646 if formal_is_conformant then do; 647 total_dims = 0; 648 649 fconf_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 650 651 call runtime_symbol_info_$type 652 (formal_type_info.base_type_addr, 653 addr (fconf_type_info), code); 654 if code ^= 0 655 then go to SOME_ERROR; 656 657 658 arg_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 659 660 call runtime_symbol_info_$type (argument.type_ptr, 661 addr (arg_type_info), code); 662 if code ^= 0 663 then go to SOME_ERROR; 664 665 if ^match_arrays (fconf_type_info, arg_type_info, 666 formal_array_info, arg_array_info, total_dims) 667 then go to invalid_arg_err; 668 call pass_conf_desc; 669 end; 670 else do; 671 if arg_type_info.size ^= formal_type_info.size 672 then go to invalid_arg_err; 673 if (arg_type_info.type ^= formal_type_info.base_type) 674 | (arg_type_info.type_addr 675 ^= formal_type_info.base_type_addr) 676 then 677 call probe_pascal_$real_type 678 ((formal_type_info.base_type), 679 formal_type_info.base_type_addr, 680 (formal_type_info.base_type), 681 formal_type_info.type_addr); 682 if (formal_type_info.base_type ^= arg_type_info.type) 683 | (formal_type_info.base_type_addr 684 ^= arg_type_info.type_addr) 685 then 686 go to invalid_arg_err; 687 end; 688 info (i) = argument.address_ptr; 689 if is_file (arg_ref_ptr) 690 then info (i) = info (i) -> based_ptr; 691 end; 692 end; 693 else if formal_type_info.type = pascal_value_formal_parameter_dtype 694 then do; 695 /* passed by value. Check is done through probe_assign_ */ 696 if formal_is_conformant then do; 697 if arg_is_conformant 698 then go to invalid_arg_err; 699 if argument.type = char_dtype then do; 700 /* char string -> PASCAL array */ 701 dcl 1 char_to_array_type, 702 2 h like 703 pascal_symbol_node_header, 704 2 bti like pascal_base_type_info, 705 2 size fixed bin (35), 706 2 ai, 707 3 access like pascal_array_info 708 .access_info, 709 3 virtual_origin fixed bin (35), 710 3 bounds like pascal_array_info.bounds; 711 712 unspec (char_to_array_type) = "0"b; 713 714 char_to_array_type.h.packed, 715 char_to_array_type.h.base_type_info, 716 char_to_array_type.h.size, 717 char_to_array_type.h.array_info = "1"b; 718 char_to_array_type.type = pascal_user_defined_type_dtype; 719 char_to_array_type.size = 9; 720 char_to_array_type.base_type = pascal_char_dtype; 721 char_to_array_type.ai.ndims = 1; 722 char_to_array_type.ai.array_units = 2; 723 char_to_array_type.virtual_origin = 1; 724 char_to_array_type.bounds.lower = 1; 725 char_to_array_type.bounds.upper = argument.precision; 726 char_to_array_type.multiplier = 1; 727 char_to_array_type.subscript_type = pascal_integer_dtype; 728 729 argument.type = pascal_user_defined_type_instance_dtype; 730 argument.type_ptr = addr (char_to_array_type); 731 argument.precision = argument.precision * 9; 732 733 arg_array_info.version = RUNTIME_ARRAY_INFO_VERSION_1; 734 735 call runtime_symbol_info_$array (argument.type_ptr, 736 addr (arg_array_info), code); 737 if code ^= 0 738 then go to SOME_ERROR; 739 end; 740 if argument.type_ptr = null 741 then go to invalid_arg_err; 742 743 arg_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 744 745 call runtime_symbol_info_$type (argument.type_ptr, 746 addr (arg_type_info), code); 747 if code ^= 0 748 then go to SOME_ERROR; 749 750 total_dims = 0; 751 752 fconf_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 753 754 call runtime_symbol_info_$type 755 (formal_type_info.base_type_addr, addr (fconf_type_info), 756 code); 757 if code ^= 0 758 then go to SOME_ERROR; 759 760 if ^match_arrays (fconf_type_info, arg_type_info, 761 formal_array_info, 762 arg_array_info, total_dims) 763 then go to invalid_arg_err; 764 call pass_conf_desc; 765 end; 766 call probe_create_reference_ (probe_info_ptr, pvalue_ref_ptr); 767 pvalue_ref.flags = "0"b; 768 pvalue_ref.name = "value argument for parameter " 769 || runtime_symbol_info_$name (formal_ptr) -> acc.string; 770 pvalue_ref.source_info_ptr = null; 771 pvalue_ref.type = formal_type_info.base_type; 772 pvalue_ref.type_ptr = formal_type_info.base_type_addr; 773 if formal_is_conformant 774 then 775 pvalue_ref.precision = argument.precision; 776 else pvalue_ref.precision = 777 decode (formal_type_info.size, 778 formal_type_info.size_is_encoded); 779 pvalue_ref.descriptor = pvalue_ref.type * 2; 780 if formal_type_info.packed 781 then 782 pvalue_ref.descriptor = pvalue_ref.descriptor + 1; 783 pvalue_ref.packed = formal_type_info.packed; 784 bit_size = 785 get_size_in_bits_ ((pvalue_ref.type), pvalue_ref.precision, 786 (pvalue_ref.packed)); 787 pvalue_ref.symbol_ptr = null; 788 pvalue_ref.address_ptr = allocate_temp ((bit_size + 35) / 36); 789 790 if formal_is_conformant 791 then 792 pvalue_ref.address_ptr -> bit_string = 793 argument.address_ptr -> bit_string; 794 else do; 795 call probe_assign_value_ (probe_info_ptr, pvalue_ref, 796 argument, code); 797 if code ^= 0 798 then go to invalid_arg_err; 799 end; 800 info (i) = pvalue_ref.address_ptr; 801 end; 802 else if formal_type_info.type = pascal_entry_formal_parameter_dtype 803 then do; 804 if argument.type = pascal_parameter_procedure_dtype then do; 805 /* nothing. good form */ 806 end; 807 if argument.type = pascal_exportable_procedure_dtype 808 | (argument.type = pascal_imported_procedure_dtype) then do; 809 temp_addr = allocate_temp (pascal_entry_parm_size); 810 temp_addr -> pascal_entry_parm.place = argument.address_ptr; 811 temp_addr -> pascal_entry_parm.frame = null; 812 temp_addr -> pascal_entry_parm.op_nbr = pascal_ext_call_op; 813 argument.address_ptr = temp_addr; 814 end; 815 else if argument.type = pascal_internal_procedure_dtype then do; 816 temp_addr = allocate_temp (pascal_entry_parm_size); 817 temp_addr -> pascal_entry_parm.place = argument.address_ptr; 818 temp_addr -> pascal_entry_parm.frame = null; 819 temp_addr -> pascal_entry_parm.op_nbr = pascal_int_call_op; 820 argument.address_ptr = temp_addr; 821 end; 822 info (i) = argument.address_ptr; 823 end; 824 formal_ptr = runtime_symbol_info_$brother (formal_ptr); 825 end; 826 if formal_ptr ^= null 827 then go to wrong_no_arg_err; 828 829 entry_type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 830 831 call runtime_symbol_info_$type (P_entry_ref.type_ptr, 832 addr (entry_type_info), code); 833 if code ^= 0 834 then go to SOME_ERROR; 835 836 if function_flag then do; 837 if entry_type_info.base_type = 0 then do; 838 call probe_error_$record (probe_info_ptr, 0, 839 "^a is not a function", P_entry_ref.name); 840 go to RECORDED_MESSAGE; 841 end; 842 allocate pascal_return_value in (expression_area) 843 set (info (number_args + 1)); 844 end; 845 else do; 846 if entry_type_info.base_type ^= 0 then do; 847 call probe_error_$record (probe_info_ptr, 0, 848 "^a is a function.", P_entry_ref.name); 849 go to RECORDED_MESSAGE; 850 end; 851 end; 852 853 call pascal_gen_call_ (entry, addr (arg_list), stack_frame, 854 operator_number, code); 855 if code ^= 0 856 then go to SOME_ERROR; 857 858 if function_flag then do; 859 P_return_ref.address_ptr = info (number_args + 1); 860 P_return_ref.type = entry_type_info.base_type; 861 P_return_ref.type_ptr = entry_type_info.base_type_addr; 862 if P_return_ref.type = pascal_integer_dtype 863 then P_return_ref.precision = 35; 864 else if P_return_ref.type = pascal_real_dtype 865 then P_return_ref.precision = 63; 866 else if P_return_ref.type = pascal_boolean_dtype 867 then P_return_ref.precision = 36; 868 else P_return_ref.precision = 72 /* pointer */; 869 P_return_ref.symbol_ptr = null; 870 P_return_ref.name = P_entry_ref.name || " [return value]"; 871 end; 872 873 /* Procedures internal to begin block for PASCAL call */ 874 875 allocate_temp: 876 procedure (words_needed) returns (pointer); 877 878 /* This routine allocates temporary storage in the stack frame of its caller. */ 879 880 dcl words_needed fixed bin parameter; 881 dcl p pointer; 882 883 call cu_$grow_stack_frame ((words_needed), p, code); 884 if code ^= 0 885 then goto SOME_ERROR; /* lossage */ 886 return (p); 887 end allocate_temp; 888 889 decode: 890 proc (value, is_encoded) returns (fixed bin (35)); 891 892 dcl value fixed bin (35); 893 /* (input) */ 894 dcl is_encoded bit (1); /* (input) */ 895 896 dcl result fixed bin (35); 897 dcl stu_$decode_runtime_value_extended 898 entry (fixed bin (35), ptr, ptr, ptr, ptr, ptr, 899 ptr, fixed bin (35)) returns (fixed bin (35)); 900 dcl ptr builtin; 901 902 if ^is_encoded 903 then 904 return (value); 905 906 result = 907 stu_$decode_runtime_value_extended (value, Block_ptr, Stack_ptr, 908 Linkage_ptr, ptr (Block_ptr, 0), 909 Base_addr, argument.type_ptr, code); 910 if code ^= 0 911 then go to SOME_ERROR; 912 return (result); 913 914 end decode; 915 916 is_conformant: 917 proc (tp, nd, ai) returns (bit (1)); 918 919 dcl tp ptr; /* (input) ptr to TYPE symbol block */ 920 dcl 1 ai like runtime_array_info; 921 /* (output) array info extracted form type TYPE box */ 922 dcl nd fixed bin (35); 923 /* (output) number of dims of this array */ 924 925 nd = 0; 926 unspec (ai) = "0"b; 927 if tp = null 928 then 929 return ("0"b); 930 931 nd = runtime_symbol_info_$array_dims (tp); 932 933 ai.version = RUNTIME_ARRAY_INFO_VERSION_1; 934 935 call runtime_symbol_info_$array (tp, addr (ai), code); 936 if code ^= 0 937 then go to SOME_ERROR; 938 939 if nd = 0 940 then return ("0"b); 941 return (ai.lower_is_encoded (1)); 942 943 end is_conformant; 944 match_arrays: 945 proc (ti1, ti2, ai1, ai2, dims) returns (bit (1)); 946 947 dcl 1 (ti1, ti2) like runtime_type_info; 948 /* (input) */ 949 dcl 1 (ai1, ai2) like runtime_array_info; 950 /* (input) */ 951 dcl dims fixed bin (35); 952 /* (output) */ 953 954 dcl i fixed bin (35); 955 dcl 1 (ai11, ai12) like runtime_array_info; 956 dcl 1 (ti11, ti12) like runtime_type_info; 957 958 if (ti1.packed ^= ti2.packed) 959 | (ti1.base_type ^= ti2.base_type) 960 | (ti1.base_type_addr ^= ti2.base_type_addr) 961 | (ai1.ndims ^= ai2.ndims) 962 then 963 return ("0"b); 964 965 if ai1.ndims = 0 966 then 967 return ("1"b); 968 969 do i = 1 to ai1.ndims; 970 if (ai1.subscript_type (i) ^= ai2.subscript_type (i)) 971 | (ai1.subscript_type_addr (i) ^= ai2.subscript_type_addr (i)) 972 then 973 return ("0"b); 974 end; 975 976 dims = dims + ai1.ndims; 977 978 if ti1.base_type_addr ^= null then do; 979 980 ti11.version = RUNTIME_TYPE_INFO_VERSION_1; 981 call runtime_symbol_info_$type (ti1.base_type_addr, addr (ti11), code); 982 if code ^= 0 983 then go to SOME_ERROR; 984 985 ti12.version = RUNTIME_TYPE_INFO_VERSION_1; 986 call runtime_symbol_info_$type (ti2.base_type_addr, addr (ti12), code); 987 if code ^= 0 988 then go to SOME_ERROR; 989 990 ai11.version = RUNTIME_ARRAY_INFO_VERSION_1; 991 call runtime_symbol_info_$array (ti1.base_type_addr, addr (ai11), code); 992 if code ^= 0 993 then go to SOME_ERROR; 994 995 ai12.version = RUNTIME_ARRAY_INFO_VERSION_1; 996 call runtime_symbol_info_$array (ti2.base_type_addr, addr (ai12), code); 997 if code ^= 0 998 then go to SOME_ERROR; 999 return (match_arrays (ti11, ti12, ai11, ai12, dims)); 1000 end; 1001 else 1002 return ("1"b); 1003 1004 end match_arrays; 1005 1006 pass_conf_desc: 1007 proc; 1008 1009 dcl 1 ai like runtime_array_info; 1010 dcl desc_len fixed bin; 1011 dcl (it, count, index) fixed bin (35); 1012 dcl 1 ti like runtime_type_info; 1013 dcl desc (desc_len) based (desc_addr) fixed bin (35); 1014 dcl desc_addr ptr; 1015 dcl tp ptr; 1016 1017 desc_len = 1 + 3 * total_dims + 1; 1018 desc_addr = allocate_temp (desc_len); 1019 info (i + possible_number) = desc_addr; 1020 index = 2 + (total_dims - 1) * 3; 1021 count = 0; 1022 ai = arg_array_info; 1023 ti = arg_type_info; 1024 do it = 1 to ai.ndims; 1025 call fill_dim; 1026 end; 1027 1028 ti.version = RUNTIME_TYPE_INFO_VERSION_1; 1029 ai.version = RUNTIME_ARRAY_INFO_VERSION_1; 1030 1031 do while (count ^= total_dims); 1032 tp = ti.base_type_addr; 1033 1034 call runtime_symbol_info_$type (tp, addr (ti), code); 1035 if code ^= 0 1036 then go to SOME_ERROR; 1037 1038 call runtime_symbol_info_$array (tp, addr (ai), code); 1039 if code ^= 0 1040 then go to SOME_ERROR; 1041 1042 do it = 1 to ai.ndims; 1043 call fill_dim; 1044 end; 1045 end; 1046 1047 fill_dim: 1048 proc; 1049 1050 desc (index) = 1051 decode (ai.lower (it), ai.lower_is_encoded (it)); 1052 desc (index + 1) = 1053 decode (ai.upper (it), ai.upper_is_encoded (it)); 1054 desc (index + 2) = 1055 convert_units (decode (ai.multiplier (it), multiplier_is_encoded (it)), 1056 (ai.array_units)); 1057 if ^fconf_type_info.packed 1058 then 1059 desc (index + 2) = desc (index + 2) / 36; 1060 /* mult in words */ 1061 index = index - 3; 1062 count = count + 1; 1063 1064 convert_units: 1065 proc (value, unit_code) returns (fixed bin (35)); 1066 dcl value fixed bin (35) parameter; 1067 /* offset in raw */ 1068 dcl unit_code fixed bin (2) parameter unsigned; 1069 1070 goto units_case (unit_code); 1071 1072 units_case (0): 1073 return (value * bits_per_word); /* word */ 1074 units_case (1): 1075 return (value); /* bit */ 1076 units_case (2): 1077 return (value * bits_per_character); /* char */ 1078 units_case (3): 1079 return (value * bits_per_half); /* halfword */ 1080 end convert_units; 1081 1082 end fill_dim; 1083 1084 end pass_conf_desc; 1085 1086 is_file: 1087 proc (ref_p) returns (bit (1)); 1088 1089 dcl ref_p ptr; 1090 dcl 1 ref like reference_node based (ref_p); 1091 1092 if ref.type = pascal_text_file_dtype 1093 then 1094 return ("1"b); 1095 1096 if ref.type = pascal_user_defined_type_instance_dtype then do; 1097 dcl 1 type_info like runtime_type_info; 1098 type_info.version = RUNTIME_TYPE_INFO_VERSION_1; 1099 call runtime_symbol_info_$type (ref.type_ptr, addr (type_info), code); 1100 if code ^= 0 1101 then go to SOME_ERROR; 1102 if type_info.type = pascal_record_file_type_dtype 1103 then 1104 return ("1"b); 1105 end; 1106 return ("0"b); 1107 1108 end is_file; 1109 1110 1111 end; /* begin block for PASCAL call */ 1112 1113 1114 1115 MAIN_RETURN: /* standard exit */ 1116 P_code = 0; 1117 return; 1118 1119 1120 SOME_ERROR: /* error exit */ 1121 P_code = code; 1122 return; 1123 1124 1125 RECORDED_MESSAGE: 1126 code = probe_et_$recorded_message; 1127 goto SOME_ERROR; 1128 1129 1 1 /* BEGIN INCLUDE FILE probe_info.incl.pl1 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(88-10-24,WAAnderson), approve(88-10-24,MCR7952), 1 7* audit(88-10-24,RWaters), install(88-10-27,MR12.2-1194): 1 8* Added field 'retry_using_main' to add new C feature. 1 9* END HISTORY COMMENTS */ 1 10 1 11 1 12 /* Created: 04/22/79 W. Olin Sibert, from subsystem_info 1 13* Modified: 22 Sept 79 JRd to remove: default (ptr & (auto|based)) init (null ()); 1 14* Added flags.setting_break 08/22/83 Steve Herbst 1 15* Added flags.executing_quit_request 01/15/85 Steve Herbst 1 16**/ 1 17 1 18 dcl 1 probe_info aligned based (probe_info_ptr), /* standard data for a probe invocation */ 1 19 2 probe_info_version fixed bin, /* version of this structure */ 1 20 1 21 2 static_info_ptr pointer unaligned, /* pointer to static information structure */ 1 22 2 modes_ptr pointer unaligned, /* pointer to probe_modes structure */ 1 23 1 24 2 ptr_to_current_source ptr, /* current_source is based on this */ 1 25 2 ptr_to_initial_source ptr, /* initial_source is based on this */ 1 26 2 machine_cond_ptr pointer, /* pointer to machine conditions, if we faulted to get here */ 1 27 1 28 2 token_info aligned, /* information about token chain currently being processed */ 1 29 3 first_token pointer unaligned, /* first token in chain */ 1 30 3 ct pointer unaligned, /* pointer to current token; updated in MANY places */ 1 31 3 end_token bit (18) aligned, /* token type at which to stop scanning token chain */ 1 32 3 buffer_ptr pointer unaligned, /* pointer to input buffer */ 1 33 3 buffer_lth fixed bin (21), /* and length */ 1 34 1 35 2 random_info aligned, 1 36 3 current_stack_frame pointer unaligned, /* stack frame pointer for frame in which probe was invoked */ 1 37 3 input_type fixed bin, /* current input type */ 1 38 3 language_type fixed bin, /* current language being processed */ 1 39 3 return_method fixed bin, /* how we should return after exiting probe */ 1 40 3 entry_method fixed bin, /* how we got here in the first place */ 1 41 3 pad1 (19) bit (36) aligned, 1 42 1 43 2 break_info, /* break info -- only interesting if we got here via a break */ 1 44 3 break_slot_ptr pointer, /* pointer to break slot -- non-null IFF at a break */ 1 45 3 last_break_slot_ptr pointer unaligned, /* pointer to previous break slot, not presently used */ 1 46 3 break_reset bit (1) aligned, /* this break has been reset by somebody further on */ 1 47 3 real_break_return_loc pointer, /* where to REALLY return to, modulo previous bit */ 1 48 1 49 2 probe_area_info, /* information about various probe areas */ 1 50 3 break_segment_ptr pointer unaligned, /* pointer to Personid.probe */ 1 51 3 break_area_ptr pointer unaligned, /* pointer to area in break segment */ 1 52 3 scratch_area_ptr pointer unaligned, /* pointer to probe scratch seg in process dir */ 1 53 3 probe_area_ptr pointer unaligned, /* This area lasts as long as an invocation of probe. */ 1 54 3 work_area_ptr pointer unaligned, /* This area lasts as long as the current request line */ 1 55 3 expression_area_ptr pointer unaligned, /* This area lasts as long as the current command */ 1 56 1 57 2 flags aligned, /* this, in particular, should be saved and restored correctly */ 1 58 (3 execute, /* "1"b => execute requests, "0"b => just check syntax */ 1 59 3 in_listener, /* ON => in probe listener loop */ 1 60 3 executing_request, /* ON => executing a request */ 1 61 3 in_interpret_line, /* executing in probe_listen_$interpret_line */ 1 62 3 setting_break, /* executing "after" or "before": check syntax of "if" */ 1 63 3 executing_quit_request, /* to prevent error looping during "quit" request */ 1 64 3 pad (30)) bit (1) unaligned, 1 65 1 66 2 io_switches, /* switches probe will do normal I/O on */ 1 67 3 input_switch pointer, 1 68 3 output_switch pointer, 1 69 1 70 2 error_info, /* information about the last error saved for later printing */ 1 71 3 error_code fixed bin (35), 1 72 3 error_message char (300) varying, 1 73 1 74 2 listener_info, /* internal use by probe listener */ 1 75 3 request_name character (32) varying, /* primary name of the request being processed */ 1 76 3 abort_probe_label label variable, 1 77 3 abort_line_label label variable, 1 78 3 depth fixed binary, /* count of active invocations of probe */ 1 79 3 previous pointer unaligned, /* -> previous invocation's info */ 1 80 3 next pointer unaligned, 1 81 1 82 2 end_of_probe_info pointer aligned, 1 83 2 retry_using_main fixed bin aligned; 1 84 1 85 1 86 dcl probe_info_ptr pointer; 1 87 1 88 dcl probe_info_version fixed bin static options (constant) initial (1); 1 89 1 90 dcl probe_info_version_1 fixed bin static options (constant) initial (1); 1 91 1 92 dcl scratch_area area based (probe_info.scratch_area_ptr); 1 93 dcl probe_area area based (probe_info.probe_area_ptr); 1 94 dcl work_area area based (probe_info.work_area_ptr); 1 95 dcl expression_area area based (probe_info.expression_area_ptr); 1 96 1 97 /* END INCLUDE FILE probe_info.incl.pl1 */ 1130 1131 2 1 /* BEGIN INCLUDE FILE ... probe_source_info.incl.pl1 2 2* 2 3* James R. Davis 2 July 79 */ 2 4 2 5 dcl 1 source_info based aligned, 2 6 2 stmnt_map_entry_index fixed bin, /* index in stmnt map for this stmnt */ 2 7 2 instruction_ptr ptr, /* to last instruction executed */ 2 8 2 block_ptr ptr, /* to runtime_block node */ 2 9 2 stack_ptr ptr, /* to a stack frame */ 2 10 2 entry_ptr ptr, /* to entry seq. for this proc */ 2 11 2 seg_info_ptr ptr; /* to seg_info */ 2 12 2 13 dcl 1 current_source aligned like source_info based (probe_info.ptr_to_current_source); 2 14 dcl 1 initial_source aligned like source_info based (probe_info.ptr_to_initial_source); 2 15 2 16 /* END INCLUDE FILE ... probe_source_info.incl.pl1 */ 1132 1133 3 1 /* BEGIN INCLUDE FILE probe_tokens.incl.pl1 */ 3 2 /* Split up into probe_tokens and probe_references, 04/22/79 WOS */ 3 3 3 4 dcl 1 token_header aligned based, /* header information common to all tokens */ 3 5 2 next pointer unaligned, /* pointer to next token in chain */ 3 6 2 prev pointer unaligned, /* same for previous token */ 3 7 2 type bit (18) aligned, 3 8 2 buffer_ptr pointer unaligned, /* pointer to beginning of input buffer */ 3 9 2 location fixed bin (17) unal, /* offset in input buffer */ 3 10 2 length fixed bin (17) unal, 3 11 2 flags aligned, 3 12 (3 leading_whitespace, /* there is whitespace before thios token */ 3 13 3 trailing_whitespace) bit (1) unaligned, /* and same for after */ 3 14 3 pad1 bit (34) unaligned; 3 15 3 16 dcl 1 token aligned based, /* produced by scan_probe_input_ */ 3 17 2 header aligned like token_header; /* that's all there is */ 3 18 3 19 dcl 1 identifier aligned based, /* keyword or identifier token */ 3 20 2 header aligned like token_header, 3 21 2 length fixed bin, /* length of name */ 3 22 2 name pointer unaligned; /* to string in buffer containing name */ 3 23 3 24 dcl 1 operator aligned based, /* for punctuation */ 3 25 2 header aligned like token_header; /* nothing but a header here */ 3 26 3 27 dcl 1 constant aligned based, /* for strings pointers numbers etc */ 3 28 2 header aligned like token_header, 3 29 2 encoded_precision aligned, /* encoded precision kludge for assign_ */ 3 30 3 scale fixed bin (17) unaligned, /* arithmetic scale */ 3 31 3 precision fixed bin (17) unaligned, /* arithmetic precision or other size */ 3 32 2 scale_and_precision fixed bin (35), /* An identical copy of the two values above */ 3 33 2 data_type fixed bin, /* standard data type code + packed bit */ 3 34 2 data_ptr pointer unaligned; 3 35 3 36 3 37 dcl (OPERATOR_TYPE init ("100"b), /* types for above */ 3 38 NAME_TYPE init ("010"b), 3 39 CONSTANT_TYPE init ("001"b)) bit (18) internal static options (constant); 3 40 3 41 3 42 dcl current_identifier_name /* Overlays for looking at the current tokens */ 3 43 char (probe_info.ct -> identifier.length) based (probe_info.ct -> identifier.name); 3 44 dcl 1 current_constant aligned like constant based (probe_info.ct); 3 45 dcl 1 current_token aligned like token based (probe_info.ct); 3 46 3 47 /* END INCLUDE FILE probe_tokens.incl.pl1 */ 1134 1135 4 1 /* BEGIN INCLUDE FILE probe_references.incl.pl1 */ 4 2 4 3 /****^ HISTORY COMMENTS: 4 4* 1) change(88-09-20,WAAnderson), approve(88-09-20,MCR7952), 4 5* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 4 6* Added new field (c_symbol) for C-Probe support. 4 7* 2) change(88-10-28,WAAnderson), approve(88-10-28,MCR7952), 4 8* audit(88-10-31,RWaters), install(88-11-11,MR12.2-1210): 4 9* Added new field (c_sub_c_ptr) for C-Probe_support. 4 10* END HISTORY COMMENTS */ 4 11 4 12 /* Split out of probe_tokens, 04/22/79 WOS */ 4 13 /* modified for probe variables Feb 19 80 JRD */ 4 14 /* Modified June 83 JMAthane to add "type_ptr" and "builtin" fields */ 4 15 4 16 dcl 1 reference_node aligned based, /* information about a reference */ 4 17 2 symbol_ptr pointer aligned, /* to symbol table entry for reference */ 4 18 2 type_ptr pointer aligned, /* to symbol table entry for type (null if none) */ 4 19 2 address_ptr pointer aligned, /* to location of variable */ 4 20 2 base_addr pointer aligned, /* pointer on which whole symbol is based */ 4 21 2 source_info_ptr pointer aligned, /* to symbol structure for reference */ 4 22 4 23 2 name char (256) unaligned varying, /* symbol name */ 4 24 4 25 2 type fixed bin (35), /* data type */ 4 26 2 descriptor fixed bin (35), /* type || packed */ 4 27 2 precision fixed bin (35), /* scale and precision */ 4 28 2 flags, 4 29 3 packed bit (1) unal, /* data is in packed format */ 4 30 3 constant bit (1) unal, /* data is really a constant */ 4 31 3 cross_section bit (1) unal, /* reference is an array cross-section */ 4 32 3 function bit (1) unal, /* reference is function value */ 4 33 3 octal bit (1) unal, /* indicates that this is the octal bif */ 4 34 3 star_extent bit (1) unal, /* reference is a star subscript for father */ 4 35 3 have_generation bit (1) unal, /* this reference has an explicitly specified generation */ 4 36 3 pseudo_var bit (1) unal, /* it is ok to assign to it */ 4 37 3 probe_variable bit (1) unal, 4 38 3 path bit (1) unal, /* it's a pathname/virtual entry */ 4 39 3 builtin bit (1) unal, /* probe builtinvalue */ 4 40 3 c_ptr_to_char bit (1) unal, 4 41 3 c_sub_c_ptr bit (1) unal, 4 42 3 pad2 bit (23) unal, 4 43 4 44 2 optional_info, /* information which may or may not be present */ 4 45 3 argument_list pointer unaligned, /* pointer to reference_arg_list */ 4 46 3 subscript_ptr pointer unaligned, /* pointer to reference_subscripts */ 4 47 3 n_arguments fixed bin, /* number of arguments in argument list */ 4 48 3 n_subscripts fixed bin, /* number of subscripts present */ 4 49 4 50 2 constant_token_ptr pointer unaligned, /* pointer to constant token if this is a constant */ 4 51 2 subscript_refs_ptr pointer unaligned, /* pointer to array of subscript reference node pointers */ 4 52 2 invocation_level fixed bin, /* invocation level number ("[-17]") for this reference */ 4 53 2 probe_var_info_ptr ptr unal, /* only if flags.probe_variable */ 4 54 2 c_symbol_ptr ptr unal, 4 55 2 pad1 (9) pointer unaligned, 4 56 2 end_of_reference_node pointer aligned; 4 57 4 58 4 59 dcl 1 reference_arg_list aligned based, /* argument list; based on reference.argument_list */ 4 60 2 number fixed bin, /* number of arguments actually present */ 4 61 2 node (16) pointer aligned; /* reference node pointers for each argument */ 4 62 4 63 4 64 dcl 1 reference_subscripts aligned based, /* subscript array; based on reference.subscript_ptr */ 4 65 2 number fixed bin, /* number actually present */ 4 66 2 value (2, 16) fixed bin (24); /* values for lower and upper bound for each */ 4 67 4 68 4 69 dcl 1 subscript_reference_ptrs aligned based, /* array of pointers to subscript reference nodes */ 4 70 2 ptr (2, 16) pointer aligned; 4 71 4 72 /* END INCLUDE FILE probe_references.incl.pl1 */ 1136 1137 5 1 /* BEGIN INCLUDE FILE ... std_descriptor_types.incl.pl1 */ 5 2 5 3 5 4 /****^ HISTORY COMMENTS: 5 5* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 5 6* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1208): 5 7* Added pascal_string_type_dtype descriptor type. Its number is 87. 5 8* Objects of this type are PASCAL string types. 5 9* 2) change(88-09-20,WAAnderson), approve(88-09-20,MCR7952), 5 10* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 5 11* Added the new C types. 5 12* END HISTORY COMMENTS */ 5 13 5 14 /* This include file defines mnemonic names for the Multics 5 15* standard descriptor types, using both pl1 and cobol terminology. 5 16* PG 780613 5 17* JRD 790530 5 18* JRD 791016 5 19* MBW 810731 5 20* TGO 830614 Add hex types. 5 21* Modified June 83 JMAthane to add PASCAL data types 5 22* TGO 840120 Add float dec extended and generic, float binary generic 5 23**/ 5 24 5 25 dcl (real_fix_bin_1_dtype init (1), 5 26 real_fix_bin_2_dtype init (2), 5 27 real_flt_bin_1_dtype init (3), 5 28 real_flt_bin_2_dtype init (4), 5 29 cplx_fix_bin_1_dtype init (5), 5 30 cplx_fix_bin_2_dtype init (6), 5 31 cplx_flt_bin_1_dtype init (7), 5 32 cplx_flt_bin_2_dtype init (8), 5 33 real_fix_dec_9bit_ls_dtype init (9), 5 34 real_flt_dec_9bit_dtype init (10), 5 35 cplx_fix_dec_9bit_ls_dtype init (11), 5 36 cplx_flt_dec_9bit_dtype init (12), 5 37 pointer_dtype init (13), 5 38 offset_dtype init (14), 5 39 label_dtype init (15), 5 40 entry_dtype init (16), 5 41 structure_dtype init (17), 5 42 area_dtype init (18), 5 43 bit_dtype init (19), 5 44 varying_bit_dtype init (20), 5 45 char_dtype init (21), 5 46 varying_char_dtype init (22), 5 47 file_dtype init (23), 5 48 real_fix_dec_9bit_ls_overp_dtype init (29), 5 49 real_fix_dec_9bit_ts_overp_dtype init (30), 5 50 real_fix_bin_1_uns_dtype init (33), 5 51 real_fix_bin_2_uns_dtype init (34), 5 52 real_fix_dec_9bit_uns_dtype init (35), 5 53 real_fix_dec_9bit_ts_dtype init (36), 5 54 real_fix_dec_4bit_uns_dtype init (38), /* digit-aligned */ 5 55 real_fix_dec_4bit_ts_dtype init (39), /* byte-aligned */ 5 56 real_fix_dec_4bit_bytealigned_uns_dtype init (40), /* COBOL */ 5 57 real_fix_dec_4bit_ls_dtype init (41), /* digit-aligned */ 5 58 real_flt_dec_4bit_dtype init (42), /* digit-aligned */ 5 59 real_fix_dec_4bit_bytealigned_ls_dtype init (43), 5 60 real_flt_dec_4bit_bytealigned_dtype init (44), 5 61 cplx_fix_dec_4bit_bytealigned_ls_dtype init (45), 5 62 cplx_flt_dec_4bit_bytealigned_dtype init (46), 5 63 real_flt_hex_1_dtype init (47), 5 64 real_flt_hex_2_dtype init (48), 5 65 cplx_flt_hex_1_dtype init (49), 5 66 cplx_flt_hex_2_dtype init (50), 5 67 c_typeref_dtype init (54), 5 68 c_enum_dtype init (55), 5 69 c_enum_const_dtype init (56), 5 70 c_union_dtype init (57), 5 71 algol68_straight_dtype init (59), 5 72 algol68_format_dtype init (60), 5 73 algol68_array_descriptor_dtype init (61), 5 74 algol68_union_dtype init (62), 5 75 5 76 cobol_comp_6_dtype init (1), 5 77 cobol_comp_7_dtype init (1), 5 78 cobol_display_ls_dtype init (9), 5 79 cobol_structure_dtype init (17), 5 80 cobol_char_string_dtype init (21), 5 81 cobol_display_ls_overp_dtype init (29), 5 82 cobol_display_ts_overp_dtype init (30), 5 83 cobol_display_uns_dtype init (35), 5 84 cobol_display_ts_dtype init (36), 5 85 cobol_comp_8_uns_dtype init (38), /* digit aligned */ 5 86 cobol_comp_5_ts_dtype init (39), /* byte aligned */ 5 87 cobol_comp_5_uns_dtype init (40), 5 88 cobol_comp_8_ls_dtype init (41), /* digit aligned */ 5 89 real_flt_dec_extended_dtype init (81), /* 9-bit exponent */ 5 90 cplx_flt_dec_extended_dtype init (82), /* 9-bit exponent */ 5 91 real_flt_dec_generic_dtype init (83), /* generic float decimal */ 5 92 cplx_flt_dec_generic_dtype init (84), 5 93 real_flt_bin_generic_dtype init (85), /* generic float binary */ 5 94 cplx_flt_bin_generic_dtype init (86)) fixed bin internal static options (constant); 5 95 5 96 dcl (ft_integer_dtype init (1), 5 97 ft_real_dtype init (3), 5 98 ft_double_dtype init (4), 5 99 ft_complex_dtype init (7), 5 100 ft_complex_double_dtype init (8), 5 101 ft_external_dtype init (16), 5 102 ft_logical_dtype init (19), 5 103 ft_char_dtype init (21), 5 104 ft_hex_real_dtype init (47), 5 105 ft_hex_double_dtype init (48), 5 106 ft_hex_complex_dtype init (49), 5 107 ft_hex_complex_double_dtype init (50) 5 108 ) fixed bin internal static options (constant); 5 109 5 110 dcl (algol68_short_int_dtype init (1), 5 111 algol68_int_dtype init (1), 5 112 algol68_long_int_dtype init (2), 5 113 algol68_real_dtype init (3), 5 114 algol68_long_real_dtype init (4), 5 115 algol68_compl_dtype init (7), 5 116 algol68_long_compl_dtype init (8), 5 117 algol68_bits_dtype init (19), 5 118 algol68_bool_dtype init (19), 5 119 algol68_char_dtype init (21), 5 120 algol68_byte_dtype init (21), 5 121 algol68_struct_struct_char_dtype init (22), 5 122 algol68_struct_struct_bool_dtype init (20) 5 123 ) fixed bin internal static options (constant); 5 124 5 125 dcl (label_constant_runtime_dtype init (24), 5 126 int_entry_runtime_dtype init (25), 5 127 ext_entry_runtime_dtype init (26), 5 128 ext_procedure_runtime_dtype init (27), 5 129 picture_runtime_dtype init (63) 5 130 ) fixed bin internal static options (constant); 5 131 5 132 dcl (pascal_integer_dtype init (1), 5 133 pascal_real_dtype init (4), 5 134 pascal_label_dtype init (24), 5 135 pascal_internal_procedure_dtype init (25), 5 136 pascal_exportable_procedure_dtype init (26), 5 137 pascal_imported_procedure_dtype init (27), 5 138 pascal_typed_pointer_type_dtype init (64), 5 139 pascal_char_dtype init (65), 5 140 pascal_boolean_dtype init (66), 5 141 pascal_record_file_type_dtype init (67), 5 142 pascal_record_type_dtype init (68), 5 143 pascal_set_dtype init (69), 5 144 pascal_enumerated_type_dtype init (70), 5 145 pascal_enumerated_type_element_dtype init (71), 5 146 pascal_enumerated_type_instance_dtype init (72), 5 147 pascal_user_defined_type_dtype init (73), 5 148 pascal_user_defined_type_instance_dtype init (74), 5 149 pascal_text_file_dtype init (75), 5 150 pascal_procedure_type_dtype init (76), 5 151 pascal_variable_formal_parameter_dtype init (77), 5 152 pascal_value_formal_parameter_dtype init (78), 5 153 pascal_entry_formal_parameter_dtype init (79), 5 154 pascal_parameter_procedure_dtype init (80), 5 155 pascal_string_type_dtype init (87)) fixed bin int static options (constant); 5 156 5 157 5 158 /* END INCLUDE FILE ... std_descriptor_types.incl.pl1 */ 1138 1139 6 1 /* BEGIN INCLUDE FILE --- acc.incl.pl1 6 2* 6 3*James R. Davis 21 Nov 78 6 4**/ 6 5 6 6 dcl 1 acc based aligned, 6 7 2 num_chars fixed bin (9) unsigned unaligned, 6 8 2 string char (0 refer (acc.num_chars)) unaligned; 6 9 6 10 /* END INCLUDE FILE --- acc.incl.pl1 */ 1140 1141 7 1 /* BEGIN INCLUDE FILE runtime_symbol_info_.incl.pl1 */ 7 2 7 3 7 4 /****^ HISTORY COMMENTS: 7 5* 1) change(86-09-05,JMAthane), approve(86-09-05,MCR7525), 7 6* audit(86-09-11,Martinson), install(86-11-12,MR12.0-1208): 7 7* Added runtime_symbol_info_$subrange entry which was missing. Added 7 8* has_dimensions and has subrange_limits fields in type_info record. 7 9* Structure version numbers have not been changed since this change does not 7 10* affect existing programs. 7 11* END HISTORY COMMENTS */ 7 12 7 13 /* Declarations for using the various entry points in runtime_symbol_info_ */ 7 14 /* NOTE: These entries do not support PL/1 version 1. */ 7 15 7 16 /* Made structures aligned, removed variable extent from runtime_array_info.bounds 08/25/83 S. Herbst */ 7 17 /* Added version strings to structures 10/05/83 S. Herbst */ 7 18 /* Added has_dimensions and has_subrange_limits bits in type_info 7 19*Added subrange entry. JMAthane 08/31/84 */ 7 20 7 21 7 22 dcl runtime_symbol_info_$type entry (ptr, ptr, fixed bin (35)); 7 23 7 24 dcl 1 runtime_type_info aligned based, 7 25 2 version char (8), /* = "RUNTYP_1" */ 7 26 2 flags, 7 27 3 aligned bit (1) unal, 7 28 3 packed bit (1) unal, 7 29 3 size_is_encoded bit (1) unal, 7 30 3 has_dimensions bit (1) unal, 7 31 3 has_subrange_limits bit (1) unal, 7 32 3 pad bit (23) unal, 7 33 2 scale fixed bin (7) unal, 7 34 2 (type, base_type) fixed bin (18) unsigned unal, 7 35 2 (type_addr, base_type_addr) ptr, 7 36 2 size fixed bin (35); 7 37 7 38 dcl runtime_symbol_info_$father entry (ptr) returns (ptr); 7 39 7 40 dcl runtime_symbol_info_$brother entry (ptr) returns (ptr); 7 41 7 42 dcl runtime_symbol_info_$father_type entry (ptr) returns (ptr); 7 43 7 44 dcl runtime_symbol_info_$son entry (ptr) returns (ptr); 7 45 7 46 dcl runtime_symbol_info_$successor entry (ptr) returns (ptr); 7 47 7 48 dcl runtime_symbol_info_$name entry (ptr) returns (ptr); 7 49 7 50 dcl runtime_symbol_info_$level entry (ptr) returns (fixed bin); 7 51 7 52 dcl runtime_symbol_info_$next entry (ptr) returns (ptr); 7 53 7 54 dcl runtime_symbol_info_$address entry (ptr, ptr, fixed bin (35)); 7 55 7 56 dcl 1 runtime_address_info aligned based, 7 57 2 version char (8), /* = "RUNADR_1" */ 7 58 2 location fixed bin (18) unsigned unal, 7 59 2 class fixed bin (6) unsigned unal, 7 60 2 use_digit fixed bin (1) unsigned unal, 7 61 2 units fixed bin (2) unsigned unal, 7 62 2 offset_is_encoded bit (1) unal, 7 63 2 pad bit (8) unal, 7 64 2 offset fixed bin (35); 7 65 7 66 dcl runtime_symbol_info_$array_dims entry (ptr) returns (fixed bin); 7 67 7 68 dcl runtime_symbol_info_$array entry (ptr, ptr, fixed bin (35)); 7 69 7 70 dcl 1 runtime_array_info aligned based, 7 71 2 version char (8), /* = "RUNARY_1" */ 7 72 2 access_info aligned, 7 73 3 ndims fixed bin (6) unsigned unaligned, /* number of dimensions */ 7 74 3 use_digit fixed bin (1) unsigned unaligned, /* if "1"b and units are half words, 7 75* units are really digits */ 7 76 3 array_units fixed bin (2) unsigned unaligned, 7 77 3 virtual_origin_is_encoded 7 78 bit (1) unaligned, 7 79 3 pad bit (26) unaligned, 7 80 2 virtual_origin fixed bin (35), 7 81 2 bounds (16) 7 82 aligned, 7 83 3 flags aligned, 7 84 4 lower_is_encoded 7 85 bit (1) unaligned, 7 86 4 upper_is_encoded 7 87 bit (1) unaligned, 7 88 4 multiplier_is_encoded 7 89 bit (1) unaligned, 7 90 4 pad bit (33) unaligned, 7 91 3 lower fixed bin (35), 7 92 3 upper fixed bin (35), 7 93 3 multiplier fixed bin (35), 7 94 3 subscript_type fixed bin (35), 7 95 3 subscript_type_addr ptr; 7 96 7 97 dcl n_dims fixed bin; 7 98 7 99 dcl runtime_symbol_info_$n_variants entry (ptr) returns (fixed bin (35)); 7 100 7 101 dcl runtime_symbol_info_$variant entry (ptr, ptr, fixed bin (35)); 7 102 7 103 dcl 1 runtime_variant_info aligned based, 7 104 2 version char (8), /* = "RUNVAR_1" */ 7 105 2 number_of_variants fixed bin, 7 106 2 first_value_in_set fixed bin (35), /* value corresponding to the first bit in set stings */ 7 107 2 case (n_variants), 7 108 3 set_addr ptr, /* bit string specifies cases; 7 109* set's base type is this node's type */ 7 110 3 brother_addr ptr; /* ptr to brother for this variant */ 7 111 7 112 dcl n_variants fixed bin (35); 7 113 7 114 dcl runtime_symbol_info_$subrange entry (ptr, ptr, fixed bin (35)); 7 115 7 116 dcl 1 runtime_subrange_info based, 7 117 2 version char (8), /* = "RUNSUB_1" */ 7 118 2 flags aligned, 7 119 3 has_subrange_limits bit (1) unal, 7 120 3 lower_bound_is_encoded bit (1) unal, 7 121 3 upper_bound_is_encoded bit (1) unal, 7 122 3 pad bit (33) unal, 7 123 2 subrange_lower_bound fixed bin (35), 7 124 2 subrange_upper_bound fixed bin (35); 7 125 7 126 7 127 dcl RUNTIME_TYPE_INFO_VERSION_1 char (8) int static options (constant) init ("RUNTYP_1"); 7 128 dcl RUNTIME_ADDRESS_INFO_VERSION_1 char (8) int static options (constant) init ("RUNADR_1"); 7 129 dcl RUNTIME_ARRAY_INFO_VERSION_1 char (8) int static options (constant) init ("RUNARY_1"); 7 130 dcl RUNTIME_VARIANT_INFO_VERSION_1 char (8) int static options (constant) init ("RUNVAR_1"); 7 131 dcl RUNTIME_SUBRANGE_INFO_VERSION_1 char (8) int static options (constant) init ("RUNSUB_1"); 7 132 7 133 7 134 /* END INCLUDE FILE runtime_symbol_info_.incl.pl1 */ 1142 1143 8 1 /* BEGIN INCLUDE FILE ... probe_seg_info.incl.pl1 8 2* 8 3* 25 June 79 JRDavis 8 4* 8 5* Modified 7 April 1983, TO - Add fields for character offset/line 8 6* correction per file. 8 7**/ 8 8 8 9 dcl 1 seg_info based aligned, /* place to remember information about object seg */ 8 10 2 language_type fixed bin, /* language of source program */ 8 11 2 bits aligned, 8 12 3 ignore_case bit (1) unal, 8 13 3 bound_segment bit (1) unaligned, 8 14 3 component bit (1) unaligned, 8 15 3 pad bit (33) unal, 8 16 2 names, /* where to find it */ 8 17 3 directory_name character (168) unal, /* what directory */ 8 18 3 entry_name character (32) unal, /* what segment */ 8 19 3 segname character (32) unal, /* procedure segname definition */ 8 20 2 identifier fixed bin (71), /* time of object creation */ 8 21 2 pointers, /* location of various parts of segment */ 8 22 3 symbol_header_ptr ptr unal, /* to symbol section */ 8 23 3 original_source_ptr ptr unal, /* to segment source map */ 8 24 3 statement_map_ptr ptr unal, /* to segment statement map */ 8 25 3 break_info ptr unal, /* for unbound segments, and start of chain for 8 26* bound ones, -> break_map !obsolete, I think! */ 8 27 3 chain ptr unal, /* to entry for next component if bound */ 8 28 3 linkage_ptr ptr unal, /* to linkage section */ 8 29 2 bounds aligned, /* structure of bounds information */ 8 30 3 text_bounds, 8 31 4 start fixed bin (35), 8 32 4 end fixed bin (35), 8 33 3 symbol_bounds, 8 34 4 start fixed bin (35), 8 35 4 end fixed bin (35), 8 36 2 map_size fixed bin, /* size of statement map */ 8 37 2 error_code fixed bin (35), /* errors encoutered while getting info, are recorded here */ 8 38 2 bound_create_time fixed bin (71), /* time seg containing was bound or compiled. */ 8 39 2 bound_sym_header ptr unal, /* to sym. section header for bound seg */ 8 40 2 pad (1) fixed bin (35), 8 41 8 42 2 nfiles fixed bin, 8 43 2 per_file (seg_info_nfiles refer (seg_info.nfiles)), 8 44 3 file_pointers ptr unal, 8 45 3 break_line (0:3) fixed bin (18) unsigned unaligned; 8 46 8 47 dcl seg_info_nfiles fixed bin; /* for allocation purposes */ 8 48 8 49 8 50 /* END INCLUDE FILE ... probe_seg_info.incl.pl1 */ 1144 1145 9 1 /* BEGIN INCLUDE FILE ... pascal_symbol_node.incl.pl1 */ 9 2 9 3 /****^ HISTORY COMMENTS: 9 4* 1) change(86-09-15,JMAthane), approve(86-09-15,MCR7525), 9 5* audit(86-09-15,Martinson), install(86-11-12,MR12.0-1208): 9 6* Added size_is_encoded field in header. 9 7* END HISTORY COMMENTS */ 9 8 9 9 /* Written January 1983 by Melanie Weaver */ 9 10 /* Added size_is_encoded field in header May 85. JMAthane */ 9 11 9 12 dcl 1 pascal_symbol_node_header aligned based, 9 13 2 flags unaligned, /* indicate which pieces the node contains */ 9 14 3 version_flag bit (1) unaligned, /* always "0"b for post-version II PL/I format */ 9 15 3 aligned bit (1) unaligned, 9 16 3 packed bit (1) unaligned, 9 17 3 in_with_block bit (1) unaligned, 9 18 3 name_next bit (1) unaligned, 9 19 3 base_type_info bit (1) unaligned, 9 20 3 address bit (1) unaligned, 9 21 3 father_brother bit (1) unaligned, 9 22 3 son_level bit (1) unaligned, 9 23 3 father_type_successor bit (1) unaligned, 9 24 3 size bit (1) unaligned, 9 25 3 offset bit (1) unaligned, 9 26 3 subrange_limits bit (1) unaligned, 9 27 3 array_info bit (1) unaligned, 9 28 3 variant_info bit (1) unaligned, 9 29 3 size_is_encoded bit (1) unaligned, 9 30 3 pad bit (2) unaligned, 9 31 2 version fixed bin (17) unaligned, /* version of this node format */ 9 32 2 type fixed bin (17) unaligned, /* (extended) data type */ 9 33 2 type_offset fixed bin (18) unsigned unaligned; /* rel ptr to type node */ 9 34 9 35 dcl 1 pascal_name_next aligned based, 9 36 2 name fixed bin (18) unsigned unaligned, /* rel ptr to acc name */ 9 37 2 next_token fixed bin (18) unsigned unaligned; /* rel ptr to next of same class */ 9 38 9 39 dcl 1 pascal_base_type_info aligned based, 9 40 2 base_type fixed bin (17) unaligned, /* type of type */ 9 41 2 base_type_offset fixed bin (18) unsigned unaligned; 9 42 9 43 dcl 1 pascal_address aligned based, 9 44 2 location fixed bin (18) unsigned unaligned, /* location in storage class */ 9 45 2 class fixed bin (6) unsigned unaligned, /* storage class */ 9 46 2 use_digit bit (1) unaligned, 9 47 2 units bit (2) unaligned, /* addressing units */ 9 48 2 offset_is_encoded bit (1) unaligned, /* "1"b if pascal_offset is encoded */ 9 49 2 pad bit (8) unaligned; 9 50 9 51 dcl 1 pascal_father_brother aligned based, 9 52 2 father fixed bin (18) unsigned unaligned, /* rel ptr to father node */ 9 53 2 brother fixed bin (18) unsigned unaligned; /* rel ptr to brother node */ 9 54 9 55 dcl 1 pascal_son_level aligned based, 9 56 2 son fixed bin (18) unsigned unaligned, /* rel ptr to son node */ 9 57 2 level fixed bin (6) unsigned unaligned, /* record level; also enum. type elt. */ 9 58 2 pad bit (12) unaligned; 9 59 9 60 dcl 1 pascal_father_type_successor aligned based, 9 61 2 father_type fixed bin (17) unaligned, 9 62 2 successor fixed bin (18) unsigned unaligned; 9 63 9 64 dcl pascal_size fixed bin (35) based; /* precision, string size, etc. */ 9 65 9 66 dcl pascal_offset fixed bin (35) based; /* offset from address */ 9 67 9 68 dcl 1 pascal_subrange_limits aligned based, 9 69 2 flags aligned, 9 70 3 lower_bound_is_encoded bit (1) unaligned, 9 71 3 upper_bound_is_encoded bit (1) unaligned, 9 72 3 pad bit (34) unaligned, 9 73 2 subrange_lower_bound 9 74 fixed bin (35), 9 75 2 subrange_upper_bound 9 76 fixed bin (35); 9 77 9 78 dcl 1 pascal_array_info aligned based, /* info about array subscripts */ 9 79 2 access_info aligned, 9 80 3 ndims fixed bin (6) unsigned unaligned, /* number of dimensions */ 9 81 3 use_digit fixed bin (1) unsigned unaligned, /* if "1"b and units are half words, 9 82* units are really digits */ 9 83 3 array_units fixed bin (2) unsigned unaligned, 9 84 3 virtual_origin_is_encoded 9 85 bit (1) unaligned, 9 86 3 pad bit (26) unaligned, 9 87 2 virtual_origin fixed bin (35), 9 88 2 bounds (nd refer (pascal_array_info.access_info.ndims)) 9 89 aligned, 9 90 3 lower fixed bin (35), 9 91 3 upper fixed bin (35), 9 92 3 multiplier fixed bin (35), 9 93 3 subscript_type fixed bin (17) unaligned, 9 94 3 subscript_type_offset 9 95 fixed bin (18) unsigned unaligned, 9 96 3 flags aligned, 9 97 4 lower_is_encoded 9 98 bit (1) unaligned, 9 99 4 upper_is_encoded 9 100 bit (1) unaligned, 9 101 4 multiplier_is_encoded 9 102 bit (1) unaligned, 9 103 4 pad bit (33) unaligned; 9 104 9 105 dcl 1 pascal_variant_info aligned based, /* info to locate a record's variants */ 9 106 2 number_of_variants 9 107 fixed bin (17) unaligned, 9 108 2 pad bit (18) unaligned, 9 109 2 first_value_in_set fixed bin (35) unaligned, /* value corresponding to the first bit in set stings */ 9 110 2 case (nvariants refer 9 111 (pascal_variant_info.number_of_variants)), 9 112 3 set_offset fixed bin (18) unsigned unaligned, /* bit string specifies cases; 9 113* set's base type is this node's type */ 9 114 3 brother fixed bin (18) unsigned unaligned; /* rel ptr to brother for this variant */ 9 115 9 116 dcl 1 pascal_encoded_value aligned based, /* extended encoded value format */ 9 117 2 code bit (6) unaligned, /* tells how to interpret the other fields */ 9 118 2 (n1, n2) bit (6) unaligned, 9 119 2 n3 fixed bin (18) unsigned unaligned; 9 120 9 121 dcl nvariants fixed bin (17); 9 122 dcl nd fixed bin (6) unsigned; 9 123 9 124 9 125 9 126 /* END INCLUDE FILE ... pascal_symbol_node.incl.pl1 */ 1146 1147 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 */ 1148 1149 1150 end; /* external procedure probe_invoke_ */ SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/88 1545.0 probe_invoke_.pl1 >spec>install>MR12.2-1210>probe_invoke_.pl1 1130 1 10/27/88 1339.2 probe_info.incl.pl1 >ldd>include>probe_info.incl.pl1 1132 2 11/26/79 1320.6 probe_source_info.incl.pl1 >ldd>include>probe_source_info.incl.pl1 1134 3 11/26/79 1320.6 probe_tokens.incl.pl1 >ldd>include>probe_tokens.incl.pl1 1136 4 11/11/88 1543.8 probe_references.incl.pl1 >spec>install>MR12.2-1210>probe_references.incl.pl1 1138 5 10/26/88 1255.5 std_descriptor_types.incl.pl1 >ldd>include>std_descriptor_types.incl.pl1 1140 6 01/15/79 2202.9 acc.incl.pl1 >ldd>include>acc.incl.pl1 1142 7 11/12/86 1748.0 runtime_symbol_info_.incl.pl1 >ldd>include>runtime_symbol_info_.incl.pl1 1144 8 11/02/83 1845.0 probe_seg_info.incl.pl1 >ldd>include>probe_seg_info.incl.pl1 1146 9 11/12/86 1748.0 pascal_symbol_node.incl.pl1 >ldd>include>pascal_symbol_node.incl.pl1 1148 10 12/07/83 1701.7 system.incl.pl1 >ldd>include>system.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. Base_addr 000614 automatic pointer dcl 573 set ref 610* 906* Block_ptr 000606 automatic pointer dcl 573 set ref 605* 906* 906 906 FB24_ALL_ONES 000037 constant fixed bin(24,0) initial dcl 54 ref 277 287 302 408 Linkage_ptr 000610 automatic pointer dcl 573 set ref 607* 906* P_code parameter fixed bin(35,0) dcl 44 set ref 121 128 1115* 1120* P_entry_ref parameter structure level 1 dcl 49 set ref 121 128 P_probe_info_ptr parameter pointer dcl 44 ref 121 128 134 P_return_ref parameter structure level 1 dcl 51 set ref 121 RUNTIME_ARRAY_INFO_VERSION_1 000004 constant char(8) initial packed unaligned dcl 7-129 ref 733 933 990 995 1029 RUNTIME_TYPE_INFO_VERSION_1 000006 constant char(8) initial packed unaligned dcl 7-127 ref 612 639 649 658 743 752 829 980 985 1028 1098 Stack_ptr 000612 automatic pointer dcl 573 set ref 606* 906* a_dims 000101 automatic fixed bin(35,0) dcl 537 set ref 624* acc based structure level 1 dcl 6-6 access 4 000616 automatic structure level 3 packed packed unaligned dcl 701 access_info 2 parameter structure level 2 in structure "ai2" dcl 949 in procedure "match_arrays" access_info based structure level 2 in structure "pascal_array_info" dcl 9-78 in procedure "probe_invoke_" access_info 2 000672 automatic structure level 2 in structure "ai" dcl 1009 in procedure "pass_conf_desc" access_info 2 parameter structure level 2 in structure "ai1" dcl 949 in procedure "match_arrays" addr builtin function dcl 117 ref 154 275 282 312 364 364 406 418 418 490 492 614 614 641 641 651 651 660 660 730 735 735 745 745 754 754 831 831 853 853 935 935 981 981 986 986 991 991 996 996 1034 1034 1038 1038 1099 1099 addrel builtin function dcl 117 ref 292 329 353 address_ptr 4 parameter pointer level 2 in structure "P_entry_ref" dcl 49 in procedure "probe_invoke_" ref 150 152 159 578 579 580 584 590 address_ptr 4 based pointer level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 688 790 810 813* 817 820* 822 address_ptr 4 based pointer level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 434* 442 address_ptr 4 parameter pointer level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 326* 328 859* address_ptr 4 based pointer level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 788* 790 800 address_ptr 4 based pointer level 2 in structure "argument" dcl 175 in begin block on line 171 ref 291 352 ai 000672 automatic structure level 1 unaligned dcl 1009 in procedure "pass_conf_desc" set ref 1022* 1038 1038 ai parameter structure level 1 unaligned dcl 920 in procedure "is_conformant" set ref 916 926* 935 935 ai 4 000616 automatic structure level 2 in structure "char_to_array_type" unaligned dcl 701 in begin block on line 522 ai1 parameter structure level 1 unaligned dcl 949 ref 944 ai11 000102 automatic structure level 1 unaligned dcl 955 set ref 991 991 999* ai12 000306 automatic structure level 1 unaligned dcl 955 set ref 996 996 999* ai2 parameter structure level 1 unaligned dcl 949 ref 944 arg_array_info 000402 automatic structure level 1 unaligned dcl 565 set ref 624* 665* 735 735 760* 1022 arg_count 2 000100 automatic fixed bin(17,0) level 3 in structure "dummy_arg_list" packed packed unaligned dcl 175 in begin block on line 171 set ref 238* 345* arg_count 2 000100 automatic fixed bin(17,0) initial level 3 in structure "dummy_arg_list" packed packed unaligned dcl 528 in begin block on line 522 set ref 528* arg_is_conformant 000151 automatic bit(1) packed unaligned dcl 558 set ref 622* 624* 697 arg_list 2 000100 automatic structure level 2 in structure "dummy_arg_list" dcl 175 in begin block on line 171 set ref 364 364 arg_list 2 000100 automatic structure level 2 in structure "dummy_arg_list" unaligned dcl 528 in begin block on line 522 set ref 853 853 arg_ref 000112 automatic pointer dcl 175 set ref 257* 258 259 272 272* 275 280* 282 282* 284 284* 288* 291 351* 352 353 353 356* arg_ref_list based structure level 1 dcl 66 arg_ref_ptr 000140 automatic pointer dcl 551 set ref 604* 605 606 607 610 622 624 629 629 641 660 688 689* 699 725 729 730 731 731 735 740 745 773 790 795 804 807 807 810 813 815 817 820 822 906 arg_type_info 000164 automatic structure level 1 unaligned dcl 561 set ref 641 641 660 660 665* 745 745 760* 1023 argument based structure level 1 dcl 371 in procedure "match_arg" set ref 436* argument based structure level 1 dcl 547 in begin block on line 522 set ref 795* argument based structure level 1 dcl 175 in begin block on line 171 argument based structure level 1 dcl 453 in procedure "build_descriptor" argument_list 117 parameter pointer level 3 packed packed unaligned dcl 49 ref 140 257 351 604 arith_to_char 000144 automatic bit(1) initial packed unaligned dcl 371 set ref 371* 415* 441 array_info 0(13) 000616 automatic bit(1) level 4 packed packed unaligned dcl 701 set ref 714* array_units 2(07) 000672 automatic fixed bin(2,0) level 3 in structure "ai" packed packed unsigned unaligned dcl 1009 in procedure "pass_conf_desc" set ref 1054 array_units 4(07) 000616 automatic fixed bin(2,0) level 4 in structure "char_to_array_type" packed packed unsigned unaligned dcl 701 in begin block on line 522 set ref 722* base_addr 6 based pointer level 2 dcl 547 set ref 610 base_type 3(18) 000114 automatic fixed bin(18,0) level 2 in structure "entry_type_info" packed packed unsigned unaligned dcl 549 in begin block on line 522 set ref 837 846 860 base_type 2 000616 automatic fixed bin(17,0) level 3 in structure "char_to_array_type" packed packed unaligned dcl 701 in begin block on line 522 set ref 720* base_type 3(18) parameter fixed bin(18,0) level 2 in structure "ti2" packed packed unsigned unaligned dcl 947 in procedure "match_arrays" ref 958 base_type 3(18) 000152 automatic fixed bin(18,0) level 2 in structure "formal_type_info" packed packed unsigned unaligned dcl 560 in begin block on line 522 set ref 673 673 673 682 771 base_type 3(18) parameter fixed bin(18,0) level 2 in structure "ti1" packed packed unsigned unaligned dcl 947 in procedure "match_arrays" ref 958 base_type_addr 6 001102 automatic pointer level 2 in structure "ti" dcl 1012 in procedure "pass_conf_desc" set ref 1032 base_type_addr 6 parameter pointer level 2 in structure "ti2" dcl 947 in procedure "match_arrays" set ref 958 986* 996* base_type_addr 6 parameter pointer level 2 in structure "ti1" dcl 947 in procedure "match_arrays" set ref 958 978 981* 991* base_type_addr 6 000114 automatic pointer level 2 in structure "entry_type_info" dcl 549 in begin block on line 522 set ref 861 base_type_addr 6 000152 automatic pointer level 2 in structure "formal_type_info" dcl 560 in begin block on line 522 set ref 619* 651* 673 673* 682 754* 772 base_type_info 0(05) 000616 automatic bit(1) level 4 packed packed unaligned dcl 701 set ref 714* based_ptr based pointer dcl 575 ref 689 based_string based char(128) packed unaligned dcl 371 ref 442 bit builtin function dcl 117 ref 483 487 490 492 bit_size 000142 automatic fixed bin(35,0) dcl 552 set ref 784* 788 790 790 bit_string based bit packed unaligned dcl 553 set ref 790* 790 bits_per_character constant fixed bin(31,0) initial dcl 10-5 ref 1076 bits_per_half constant fixed bin(31,0) initial dcl 10-5 ref 1078 bits_per_word constant fixed bin(31,0) initial dcl 10-5 ref 1072 block_ptr 4 based pointer level 2 dcl 2-5 set ref 317* 605 bounds 4 000672 automatic structure array level 2 in structure "ai" dcl 1009 in procedure "pass_conf_desc" bounds 2 based structure array level 2 in structure "pascal_array_info" dcl 9-78 in procedure "probe_invoke_" bounds 4 parameter structure array level 2 in structure "ai" dcl 920 in procedure "is_conformant" bounds 4 parameter structure array level 2 in structure "ai1" dcl 949 in procedure "match_arrays" bounds 6 000616 automatic structure level 3 in structure "char_to_array_type" unaligned dcl 701 in begin block on line 522 bounds 4 parameter structure array level 2 in structure "ai2" dcl 949 in procedure "match_arrays" bti 2 000616 automatic structure level 2 packed packed unaligned dcl 701 call_code 2(18) 000100 automatic fixed bin(17,0) initial level 3 in structure "dummy_arg_list" packed packed unaligned dcl 175 in begin block on line 171 set ref 175* call_code 2(18) 000100 automatic fixed bin(17,0) initial level 3 in structure "dummy_arg_list" packed packed unaligned dcl 528 in begin block on line 522 set ref 528* ceil builtin function dcl 117 ref 422 char_dtype constant fixed bin(17,0) initial dcl 5-25 ref 699 char_to_array_type 000616 automatic structure level 1 unaligned dcl 701 set ref 712* 730 code 000110 automatic fixed bin(35,0) dcl 63 set ref 218* 220 220 220 224* 268* 436* 438 513* 514 614* 616 641* 643 651* 654 660* 662 735* 737 745* 747 754* 757 795* 797 831* 833 853* 855 883* 884 906* 910 935* 936 981* 982 986* 987 991* 992 996* 997 1034* 1035 1038* 1039 1099* 1100 1120 1125* constant based structure level 1 dcl 3-27 in procedure "probe_invoke_" constant 116(01) parameter bit(1) level 3 in structure "P_return_ref" packed packed unaligned dcl 51 in procedure "probe_invoke_" set ref 314* count 001100 automatic fixed bin(35,0) dcl 1011 set ref 1021* 1031 1062* 1062 cu_$gen_call 000042 constant entry external dcl 110 ref 364 cu_$grow_stack_frame 000044 constant entry external dcl 111 ref 513 883 decode_descriptor_ 000046 constant entry external dcl 112 ref 264 300 desc based fixed bin(35,0) array dcl 1013 set ref 1050* 1052* 1054* 1057* 1057 desc_addr 001114 automatic pointer dcl 1014 set ref 1018* 1019 1050 1052 1054 1057 1057 desc_count 3 000100 automatic fixed bin(17,0) initial level 3 in structure "dummy_arg_list" packed packed unaligned dcl 528 in begin block on line 522 set ref 528* desc_count 3 000100 automatic fixed bin(17,0) level 3 in structure "dummy_arg_list" packed packed unaligned dcl 175 in begin block on line 171 set ref 240* 347* desc_len 001076 automatic fixed bin(17,0) dcl 1010 set ref 1017* 1018* desc_origin 000100 automatic fixed bin(17,0) dcl 175 set ref 241* 288 290 333 348* 356 desc_ptrs 000100 automatic pointer array dcl 175 set ref 218* 264* 290 300* 333 descriptor 114 parameter fixed bin(35,0) level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 310* descriptor based structure level 1 dcl 453 in procedure "build_descriptor" set ref 479 479 descriptor 114 based fixed bin(35,0) level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 404* descriptor 114 based fixed bin(35,0) level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 779* 780* 780 dims parameter fixed bin(35,0) dcl 951 set ref 944 976* 976 999* divide builtin function dcl 117 ref 324 432 dp 000154 automatic pointer dcl 453 set ref 479* 479 479 482 483 484 485 487 490 492 497 dummy_arg_list 000100 automatic structure level 1 dcl 175 in begin block on line 171 dummy_arg_list 000100 automatic structure level 1 unaligned dcl 528 in begin block on line 522 encoded based structure level 1 dcl 72 entry 000104 automatic pointer dcl 61 set ref 150* 159* 218* 364* 578* 584* 590* 853* entry_ptr 10 based pointer level 2 dcl 2-5 set ref 317* entry_type_info 000114 automatic structure level 1 unaligned dcl 549 set ref 831 831 entry_var based structure level 1 dcl 77 error_table_$lower_ring 000010 external static fixed bin(35,0) dcl 88 ref 220 error_table_$nodescr 000012 external static fixed bin(35,0) dcl 88 ref 220 expression_area based area(1024) dcl 1-95 ref 842 expression_area_ptr 63 based pointer level 3 packed packed unaligned dcl 1-18 ref 842 f_dims 000100 automatic fixed bin(35,0) dcl 537 set ref 619* fconf_type_info 000126 automatic structure level 1 unaligned dcl 550 set ref 651 651 665* 754 754 760* fixed builtin function dcl 117 ref 142 310 404 483 487 490 492 flag based bit(1) level 2 packed packed unaligned dcl 453 set ref 482* flags 116 based structure level 2 in structure "argument" dcl 453 in procedure "build_descriptor" flags 116 parameter structure level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 313* flags 2 000126 automatic structure level 2 in structure "fconf_type_info" packed packed unaligned dcl 550 in begin block on line 522 flags 2 parameter structure level 2 in structure "ti2" packed packed unaligned dcl 947 in procedure "match_arrays" flags 4 parameter structure array level 3 in structure "ai" dcl 920 in procedure "is_conformant" flags 000616 automatic structure level 3 in structure "char_to_array_type" packed packed unaligned dcl 701 in begin block on line 522 flags 2 parameter structure level 2 in structure "ti1" packed packed unaligned dcl 947 in procedure "match_arrays" flags 2 000152 automatic structure level 2 in structure "formal_type_info" packed packed unaligned dcl 560 in begin block on line 522 flags 116 based structure level 2 in structure "argument" dcl 175 in begin block on line 171 flags 116 based structure level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 428* flags 4 000672 automatic structure array level 3 in structure "ai" dcl 1009 in procedure "pass_conf_desc" flags 116 based structure level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 767* formal_array_info 000176 automatic structure level 1 unaligned dcl 564 set ref 619* 665* 760* formal_is_conformant 000150 automatic bit(1) packed unaligned dcl 558 set ref 619* 646 696 773 790 formal_ptr 000110 automatic pointer dcl 543 set ref 595* 598 614* 768* 824* 824* 826 formal_type_info 000152 automatic structure level 1 unaligned dcl 560 set ref 614 614 frame 2 based pointer level 2 in structure "pascal_entry_parm" dcl 566 in begin block on line 522 set ref 579 811* 818* frame 2 based pointer level 2 in structure "entry_var" dcl 77 in procedure "probe_invoke_" ref 152 function_flag 000100 automatic bit(1) packed unaligned dcl 58 set ref 124* 131* 142 243 299 339 836 858 get_entry_arg_descs_ 000050 constant entry external dcl 114 ref 218 get_size_in_bits_ 000070 constant entry external dcl 555 ref 784 h 000616 automatic structure level 2 packed packed unaligned dcl 701 i 000143 automatic fixed bin(17,0) dcl 371 in procedure "match_arg" set ref 418* 420 420* 422* 422 424* 424 425 442* 443 i 000146 automatic fixed bin(35,0) dcl 557 in begin block on line 522 set ref 597* 604 631* 688 689 689 800 822* 1019 i 000100 automatic fixed bin(35,0) dcl 954 in procedure "match_arrays" set ref 969* 970 970 970 970* i 000114 automatic fixed bin(17,0) dcl 175 in begin block on line 171 set ref 256* 257 264 288 290 290 291 292 292* 323* 324 324* 324 324 326* 350* 351 352 353 353 356* index 001101 automatic fixed bin(35,0) dcl 1011 set ref 1020* 1050 1052 1054 1057 1057 1061* 1061 info 4 000100 automatic pointer array level 3 in structure "dummy_arg_list" dcl 528 in begin block on line 522 set ref 688* 689* 689 800* 822* 842* 859 1019* info 4 000100 automatic pointer array level 3 in structure "dummy_arg_list" dcl 175 in begin block on line 171 set ref 288* 290* 291* 292* 292 328* 329* 329 333* 352* 353* 353 356* is_encoded parameter bit(1) packed unaligned dcl 894 ref 889 902 it 001077 automatic fixed bin(35,0) dcl 1011 set ref 1024* 1042* 1050 1050 1052 1052 1054 1054 1054 1054 linkage_ptr 103 based pointer level 3 packed packed unaligned dcl 8-9 ref 607 lower 5 000672 automatic fixed bin(35,0) array level 3 in structure "ai" dcl 1009 in procedure "pass_conf_desc" set ref 1050* lower 6 000616 automatic fixed bin(35,0) level 4 in structure "char_to_array_type" dcl 701 in begin block on line 522 set ref 724* lower_is_encoded 4 parameter bit(1) array level 4 in structure "ai" packed packed unaligned dcl 920 in procedure "is_conformant" set ref 941 lower_is_encoded 4 000672 automatic bit(1) array level 4 in structure "ai" packed packed unaligned dcl 1009 in procedure "pass_conf_desc" set ref 1050* match 000107 automatic bit(1) packed unaligned dcl 175 set ref 220* 229* 232 min builtin function dcl 117 ref 424 multiplier 10 000616 automatic fixed bin(35,0) level 4 in structure "char_to_array_type" dcl 701 in begin block on line 522 set ref 726* multiplier 7 000672 automatic fixed bin(35,0) array level 3 in structure "ai" dcl 1009 in procedure "pass_conf_desc" set ref 1054* 1054* multiplier_is_encoded 4(02) 000672 automatic bit(1) array level 4 packed packed unaligned dcl 1009 set ref 1054* 1054* must_build 000110 automatic bit(1) packed unaligned dcl 175 set ref 287* 288 name 12 parameter varying char(256) level 2 in structure "P_entry_ref" dcl 49 in procedure "probe_invoke_" set ref 164* 224* 244* 250* 303* 308 340* 599* 631* 838* 847* 870 name 12 based varying char(256) level 2 in structure "argument" dcl 175 in begin block on line 171 set ref 259* name 12 based varying char(256) level 2 in structure "argument" dcl 453 in procedure "build_descriptor" set ref 475* name 12 based varying char(256) level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 401* name 12 based varying char(256) level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 629 name 12 based varying char(256) level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 768* name 12 parameter varying char(256) level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 308* 870* nd parameter fixed bin(35,0) dcl 922 set ref 916 925* 931* 939 ndims 000103 automatic fixed bin(17,0) dcl 175 in begin block on line 171 set ref 264* 267 300* 302 ndims 2 000672 automatic fixed bin(6,0) level 3 in structure "ai" packed packed unsigned unaligned dcl 1009 in procedure "pass_conf_desc" set ref 1024 1042 ndims 2 parameter fixed bin(6,0) level 3 in structure "ai2" packed packed unsigned unaligned dcl 949 in procedure "match_arrays" ref 958 ndims 2 parameter fixed bin(6,0) level 3 in structure "ai1" packed packed unsigned unaligned dcl 949 in procedure "match_arrays" ref 958 965 969 976 ndims 0(08) based bit(4) level 2 in structure "descriptor" packed packed unaligned dcl 453 in procedure "build_descriptor" set ref 485* ndims 4 000616 automatic fixed bin(6,0) level 4 in structure "char_to_array_type" packed packed unsigned unaligned dcl 701 in begin block on line 522 set ref 721* need 000142 automatic fixed bin(17,0) dcl 371 set ref 431* 432 432* 432 432 434* node 2 based pointer array level 2 dcl 66 ref 257 351 604 null builtin function dcl 117 ref 145 160 163 316 317 317 400 591 598 622 629 740 770 787 811 818 826 869 927 978 num_chars based fixed bin(9,0) level 2 packed packed unsigned unaligned dcl 6-6 ref 768 number based fixed bin(17,0) level 2 dcl 66 ref 140 number_args 000101 automatic fixed bin(17,0) dcl 59 set ref 140* 142 243 256 350 597 842 859 number_descs 000101 automatic fixed bin(17,0) dcl 175 set ref 218* 236 243 300 328 329 329 333 333 op_nbr 4 based fixed bin(35,0) level 2 dcl 566 set ref 580 812* 819* operator_number 000112 automatic fixed bin(35,0) dcl 546 set ref 580* 586* 592* 853* optional_info 117 parameter structure level 2 dcl 49 p 000644 automatic pointer dcl 881 in procedure "allocate_temp" set ref 883* 886 p 000164 automatic pointer dcl 511 in procedure "allocate_temp" set ref 513* 516 packed parameter bit(1) packed unaligned dcl 371 in procedure "match_arg" ref 367 404 429 packed 116 based bit(1) level 3 in structure "argument" packed packed unaligned dcl 453 in procedure "build_descriptor" ref 484 packed 000106 automatic bit(1) packed unaligned dcl 175 in begin block on line 171 set ref 264* 272* 280* 282* 284 284* 300* 310 315 packed 2(01) parameter bit(1) level 3 in structure "ti1" packed packed unaligned dcl 947 in procedure "match_arrays" ref 958 packed 0(02) 000616 automatic bit(1) level 4 in structure "char_to_array_type" packed packed unaligned dcl 701 in begin block on line 522 set ref 714* packed 2(01) 000152 automatic bit(1) level 3 in structure "formal_type_info" packed packed unaligned dcl 560 in begin block on line 522 set ref 780 783 packed 0(07) based bit(1) level 2 in structure "descriptor" packed packed unaligned dcl 453 in procedure "build_descriptor" set ref 484* packed 2(01) parameter bit(1) level 3 in structure "ti2" packed packed unaligned dcl 947 in procedure "match_arrays" ref 958 packed 2(01) 000126 automatic bit(1) level 3 in structure "fconf_type_info" packed packed unaligned dcl 550 in begin block on line 522 set ref 1057 packed 116 based bit(1) level 3 in structure "pvalue_ref" packed packed unaligned dcl 562 in begin block on line 522 set ref 783* 784 packed 116 based bit(1) level 3 in structure "temp" packed packed unaligned dcl 371 in procedure "match_arg" set ref 429* packed 116 parameter bit(1) level 3 in structure "P_return_ref" packed packed unaligned dcl 51 in procedure "probe_invoke_" set ref 315* packed 116 based bit(1) level 3 in structure "argument" packed packed unaligned dcl 175 in begin block on line 171 ref 284 pascal_array_info based structure level 1 dcl 9-78 pascal_base_type_info based structure level 1 dcl 9-39 pascal_boolean_dtype constant fixed bin(17,0) initial dcl 5-132 ref 866 pascal_char_dtype constant fixed bin(17,0) initial dcl 5-132 ref 720 pascal_entry_formal_parameter_dtype constant fixed bin(17,0) initial dcl 5-132 ref 802 pascal_entry_parm based structure level 1 unaligned dcl 566 pascal_entry_parm_size 000104 automatic fixed bin(17,0) initial dcl 541 set ref 541* 809* 816* pascal_exportable_procedure_dtype constant fixed bin(17,0) initial dcl 5-132 ref 588 807 pascal_ext_call_op 000103 automatic fixed bin(35,0) initial dcl 539 set ref 539* 592 812 pascal_gen_call_ 000066 constant entry external dcl 544 ref 853 pascal_imported_procedure_dtype constant fixed bin(17,0) initial dcl 5-132 ref 588 807 pascal_int_call_op 000102 automatic fixed bin(35,0) initial dcl 538 set ref 538* 586 819 pascal_integer_dtype constant fixed bin(17,0) initial dcl 5-132 ref 727 862 pascal_internal_procedure_dtype constant fixed bin(17,0) initial dcl 5-132 ref 583 815 pascal_parameter_procedure_dtype constant fixed bin(17,0) initial dcl 5-132 ref 577 804 pascal_real_dtype constant fixed bin(17,0) initial dcl 5-132 ref 864 pascal_record_file_type_dtype constant fixed bin(17,0) initial dcl 5-132 ref 1102 pascal_return_value based fixed bin(35,0) dcl 540 ref 842 pascal_symbol_node_header based structure level 1 dcl 9-12 pascal_text_file_dtype constant fixed bin(17,0) initial dcl 5-132 ref 1092 pascal_user_defined_type_dtype constant fixed bin(17,0) initial dcl 5-132 ref 718 pascal_user_defined_type_instance_dtype constant fixed bin(17,0) initial dcl 5-132 ref 729 1096 pascal_value_formal_parameter_dtype constant fixed bin(17,0) initial dcl 5-132 ref 693 pascal_variable_formal_parameter_dtype constant fixed bin(17,0) initial dcl 5-132 ref 626 place based pointer level 2 in structure "entry_var" dcl 77 in procedure "probe_invoke_" ref 150 place based pointer level 2 in structure "pascal_entry_parm" dcl 566 in begin block on line 522 set ref 578 810* 817* pointers 76 based structure level 2 dcl 8-9 possible_number 000102 automatic fixed bin(17,0) dcl 60 set ref 142* 175 175 236 238 240 241 345 347 348 528 528 1019 precision 115 based fixed bin(35,0) level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 773* 776* 784* precision 0(18) based fixed bin(17,0) level 2 in structure "encoded" packed packed unaligned dcl 72 in procedure "probe_invoke_" ref 275 418 492 precision 115 parameter fixed bin(35,0) level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 311* 312 862* 864* 866* 868* precision 115 based fixed bin(35,0) level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 405* 406 408* 414* 425* 432 443* precision 115 based fixed bin(35,0) level 2 in structure "argument" dcl 453 in procedure "build_descriptor" set ref 487 490 492 precision 115 based fixed bin(35,0) level 2 in structure "argument" dcl 371 in procedure "match_arg" set ref 418 418 precision 115 based fixed bin(35,0) level 2 in structure "argument" dcl 175 in begin block on line 171 set ref 275 282 precision parameter fixed bin(17,0) dcl 371 in procedure "match_arg" ref 367 405 408 408 precision 115 based fixed bin(35,0) level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 725 731* 731 773 probe_area_info 56 based structure level 2 dcl 1-18 probe_assign_value_ 000034 constant entry external dcl 101 ref 436 795 probe_create_reference_ 000074 constant entry external dcl 572 ref 766 probe_error_$malfunction 000040 constant entry external dcl 107 ref 28 probe_error_$record 000036 constant entry external dcl 106 ref 164 224 244 250 259 303 340 475 599 631 838 847 probe_et_$array_arg 000014 external static fixed bin(35,0) dcl 88 ref 268 probe_et_$bad_return_val 000016 external static fixed bin(35,0) dcl 88 set ref 303* probe_et_$int_proc 000020 external static fixed bin(35,0) dcl 88 set ref 164* probe_et_$no_return_desc 000022 external static fixed bin(35,0) dcl 88 set ref 340* probe_et_$not_function 000024 external static fixed bin(35,0) dcl 88 set ref 244* probe_et_$recorded_message 000026 external static fixed bin(35,0) dcl 88 ref 1125 probe_et_$struc_arg 000030 external static fixed bin(35,0) dcl 88 set ref 259* 475* probe_et_$wrong_no_args 000032 external static fixed bin(35,0) dcl 88 set ref 250* 599* probe_info based structure level 1 dcl 1-18 probe_info_ptr 000112 automatic pointer dcl 1-86 set ref 134* 164* 224* 244* 250* 259* 303* 340* 436* 475* 599* 631* 766* 795* 838* 842 847* probe_pascal_$real_type 000072 constant entry external dcl 570 ref 673 ptr builtin function dcl 900 ref 906 906 pvalue_ref based structure level 1 dcl 562 set ref 795* pvalue_ref_ptr 000106 automatic pointer dcl 542 set ref 766* 767 768 770 771 772 773 776 779 779 780 780 783 784 784 784 787 788 790 795 800 ref based structure level 1 unaligned dcl 1090 in procedure "is_file" ref parameter pointer dcl 453 in procedure "build_descriptor" ref 449 474 475 483 484 487 487 490 492 ref parameter pointer dcl 371 in procedure "match_arg" set ref 367 408 418 418 422 436 445* ref_p parameter pointer dcl 1089 ref 1086 1092 1096 1099 reference_node based structure level 1 dcl 4-16 result 000654 automatic fixed bin(35,0) dcl 896 set ref 906* 912 reverse builtin function dcl 117 ref 442 runtime_array_info based structure level 1 dcl 7-70 runtime_symbol_info_$array 000064 constant entry external dcl 7-68 ref 735 935 991 996 1038 runtime_symbol_info_$array_dims 000062 constant entry external dcl 7-66 ref 931 runtime_symbol_info_$brother 000054 constant entry external dcl 7-40 ref 824 runtime_symbol_info_$name 000060 constant entry external dcl 7-48 ref 768 runtime_symbol_info_$son 000056 constant entry external dcl 7-44 ref 595 runtime_symbol_info_$type 000052 constant entry external dcl 7-22 ref 614 641 651 660 745 754 831 981 986 1034 1099 runtime_type_info based structure level 1 dcl 7-24 scale parameter fixed bin(17,0) dcl 371 in procedure "match_arg" ref 367 406 scale based fixed bin(17,0) level 2 in structure "encoded" packed packed unaligned dcl 72 in procedure "probe_invoke_" set ref 282 312* 406* 418 490 scale 000105 automatic fixed bin(17,0) dcl 175 in begin block on line 171 set ref 264* 272* 280* 282 282* 284* 300* 312 seg_info based structure level 1 dcl 8-9 seg_info_ptr 12 based pointer level 2 dcl 2-5 ref 607 size builtin function dcl 371 in procedure "match_arg" ref 398 398 size 000104 automatic fixed bin(17,0) dcl 175 in begin block on line 171 set ref 264* 272* 275 277 280* 282* 284* 287 300* 302 311 324 size 3 000616 automatic fixed bin(35,0) level 2 in structure "char_to_array_type" dcl 701 in begin block on line 522 set ref 719* size 10 000152 automatic fixed bin(35,0) level 2 in structure "formal_type_info" dcl 560 in begin block on line 522 set ref 671 776* size 0(10) 000616 automatic bit(1) level 4 in structure "char_to_array_type" packed packed unaligned dcl 701 in begin block on line 522 set ref 714* size builtin function dcl 453 in procedure "build_descriptor" ref 479 479 size 10 000164 automatic fixed bin(35,0) level 2 in structure "arg_type_info" dcl 561 in begin block on line 522 set ref 671 size 0(12) based bit(24) level 2 in structure "descriptor" packed packed unaligned dcl 453 in procedure "build_descriptor" set ref 487* 490* 492* size_is_encoded 2(02) 000152 automatic bit(1) level 3 packed packed unaligned dcl 560 set ref 776* source_info based structure level 1 dcl 2-5 source_info_ptr 10 based pointer level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 605 606 607 source_info_ptr 10 parameter pointer level 2 in structure "P_entry_ref" dcl 49 in procedure "probe_invoke_" ref 585 source_info_ptr 10 based pointer level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 400* source_info_ptr 10 based pointer level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 770* source_info_ptr 10 parameter pointer level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" ref 317 317 317 317 stack_frame 000106 automatic pointer dcl 62 set ref 152* 154* 154 160* 163 579* 585* 591* 853* stack_ptr 6 based pointer level 2 dcl 2-5 set ref 317* 585 606 string 0(09) based char level 2 packed packed unaligned dcl 6-6 ref 768 structure_dtype constant fixed bin(17,0) initial dcl 5-25 ref 258 stu_$decode_runtime_value_extended 000076 constant entry external dcl 897 ref 906 subscript_type 10 parameter fixed bin(35,0) array level 3 in structure "ai2" dcl 949 in procedure "match_arrays" ref 970 subscript_type 11 000616 automatic fixed bin(17,0) level 4 in structure "char_to_array_type" packed packed unaligned dcl 701 in begin block on line 522 set ref 727* subscript_type 10 parameter fixed bin(35,0) array level 3 in structure "ai1" dcl 949 in procedure "match_arrays" ref 970 subscript_type_addr 12 parameter pointer array level 3 in structure "ai2" dcl 949 in procedure "match_arrays" ref 970 subscript_type_addr 12 parameter pointer array level 3 in structure "ai1" dcl 949 in procedure "match_arrays" ref 970 substr builtin function dcl 117 set ref 490* 492* symbol_ptr parameter pointer level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 316* 869* symbol_ptr based pointer level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 629 641* symbol_ptr based pointer level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 787* symbol_ptr based pointer level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 400* temp based structure level 1 dcl 371 set ref 398 398 436* temp_addr 000144 automatic pointer dcl 554 set ref 809* 810 811 812 813 816* 817 818 819 820 ti 001102 automatic structure level 1 unaligned dcl 1012 set ref 1023* 1034 1034 ti1 parameter structure level 1 unaligned dcl 947 set ref 944 ti11 000512 automatic structure level 1 unaligned dcl 956 set ref 981 981 999* ti12 000524 automatic structure level 1 unaligned dcl 956 set ref 986 986 999* ti2 parameter structure level 1 unaligned dcl 947 set ref 944 token based structure level 1 dcl 3-16 token_header based structure level 1 dcl 3-4 total_dims 000147 automatic fixed bin(35,0) dcl 557 set ref 647* 665* 750* 760* 1017 1020 1031 tp 001116 automatic pointer dcl 1015 in procedure "pass_conf_desc" set ref 1032* 1034* 1038* tp parameter pointer dcl 919 in procedure "is_conformant" set ref 916 927 931* 935* tref 000140 automatic pointer dcl 371 set ref 398* 398 398 400 400 401 403 404 405 406 408 414 425 428 429 432 434 436 442 443 445 type 1 000616 automatic fixed bin(17,0) level 3 in structure "char_to_array_type" packed packed unaligned dcl 701 in begin block on line 522 set ref 718* type 0(01) based bit(6) level 2 in structure "descriptor" packed packed unaligned dcl 453 in procedure "build_descriptor" set ref 483* type 000102 automatic fixed bin(17,0) dcl 175 in begin block on line 171 set ref 264* 272 272* 280* 282* 284* 292 292 300* 309 310 323 329 329 type 113 based fixed bin(35,0) level 2 in structure "temp" dcl 371 in procedure "match_arg" set ref 403* type 113 based fixed bin(35,0) level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 699 729* 804 807 807 815 type 3 000164 automatic fixed bin(18,0) level 2 in structure "arg_type_info" packed packed unsigned unaligned dcl 561 in begin block on line 522 set ref 673 682 type 113 based fixed bin(35,0) level 2 in structure "argument" dcl 453 in procedure "build_descriptor" ref 474 483 487 type parameter fixed bin(17,0) dcl 371 in procedure "match_arg" ref 367 403 404 412 431 type 113 parameter fixed bin(35,0) level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 309* 860* 862 864 866 type 113 based fixed bin(35,0) level 2 in structure "argument" dcl 175 in begin block on line 171 ref 258 272 353 353 type 3 001156 automatic fixed bin(18,0) level 2 in structure "type_info" packed packed unsigned unaligned dcl 1097 in procedure "is_file" set ref 1102 type 3 000152 automatic fixed bin(18,0) level 2 in structure "formal_type_info" packed packed unsigned unaligned dcl 560 in begin block on line 522 set ref 626 693 802 type 113 based fixed bin(35,0) level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 771* 779 784 type 113 based fixed bin(35,0) level 2 in structure "argument" dcl 371 in procedure "match_arg" set ref 408 422 type 113 based fixed bin(35,0) level 2 in structure "ref" dcl 1090 in procedure "is_file" ref 1092 1096 type 113 parameter fixed bin(35,0) level 2 in structure "P_entry_ref" dcl 49 in procedure "probe_invoke_" ref 148 154 577 583 588 588 type_addr 4 000152 automatic pointer level 2 in structure "formal_type_info" dcl 560 in begin block on line 522 set ref 673* type_addr 4 000164 automatic pointer level 2 in structure "arg_type_info" dcl 561 in begin block on line 522 set ref 673 682 type_info 001156 automatic structure level 1 unaligned dcl 1097 set ref 1099 1099 type_ptr 2 parameter pointer level 2 in structure "P_entry_ref" dcl 49 in procedure "probe_invoke_" set ref 145 595* 831* type_ptr 2 based pointer level 2 in structure "argument" dcl 547 in begin block on line 522 set ref 622 624* 660* 730* 735* 740 745* 906* type_ptr 2 based pointer level 2 in structure "ref" dcl 1090 in procedure "is_file" set ref 1099* type_ptr 2 based pointer level 2 in structure "pvalue_ref" dcl 562 in begin block on line 522 set ref 772* type_ptr 2 parameter pointer level 2 in structure "P_return_ref" dcl 51 in procedure "probe_invoke_" set ref 861* type_size 000010 constant fixed bin(17,0) initial array dcl 82 ref 323 431 unit_code parameter fixed bin(2,0) unsigned dcl 1068 ref 1064 1070 unspec builtin function dcl 117 set ref 712* 926* upper 7 000616 automatic fixed bin(35,0) level 4 in structure "char_to_array_type" dcl 701 in begin block on line 522 set ref 725* upper 6 000672 automatic fixed bin(35,0) array level 3 in structure "ai" dcl 1009 in procedure "pass_conf_desc" set ref 1052* upper_is_encoded 4(01) 000672 automatic bit(1) array level 4 packed packed unaligned dcl 1009 set ref 1052* value parameter fixed bin(35,0) dcl 892 in procedure "decode" set ref 889 902 906* value parameter fixed bin(35,0) dcl 1066 in procedure "convert_units" ref 1064 1072 1074 1076 1078 verify builtin function dcl 117 ref 442 version 000152 automatic char(8) level 2 in structure "formal_type_info" packed packed unaligned dcl 560 in begin block on line 522 set ref 612* version 000524 automatic char(8) level 2 in structure "ti12" packed packed unaligned dcl 956 in procedure "match_arrays" set ref 985* version 001156 automatic char(8) level 2 in structure "type_info" packed packed unaligned dcl 1097 in procedure "is_file" set ref 1098* version 000114 automatic char(8) level 2 in structure "entry_type_info" packed packed unaligned dcl 549 in begin block on line 522 set ref 829* version 000102 automatic char(8) level 2 in structure "ai11" packed packed unaligned dcl 955 in procedure "match_arrays" set ref 990* version 000672 automatic char(8) level 2 in structure "ai" packed packed unaligned dcl 1009 in procedure "pass_conf_desc" set ref 1029* version 000306 automatic char(8) level 2 in structure "ai12" packed packed unaligned dcl 955 in procedure "match_arrays" set ref 995* version parameter char(8) level 2 in structure "ai" packed packed unaligned dcl 920 in procedure "is_conformant" set ref 933* version 000164 automatic char(8) level 2 in structure "arg_type_info" packed packed unaligned dcl 561 in begin block on line 522 set ref 639* 658* 743* version 000402 automatic char(8) level 2 in structure "arg_array_info" packed packed unaligned dcl 565 in begin block on line 522 set ref 733* version 001102 automatic char(8) level 2 in structure "ti" packed packed unaligned dcl 1012 in procedure "pass_conf_desc" set ref 1028* version 000512 automatic char(8) level 2 in structure "ti11" packed packed unaligned dcl 956 in procedure "match_arrays" set ref 980* version 000126 automatic char(8) level 2 in structure "fconf_type_info" packed packed unaligned dcl 550 in begin block on line 522 set ref 649* 752* virtual_origin 5 000616 automatic fixed bin(35,0) level 3 dcl 701 set ref 723* words_needed parameter fixed bin(17,0) dcl 510 in procedure "allocate_temp" ref 503 513 words_needed parameter fixed bin(17,0) dcl 880 in procedure "allocate_temp" ref 875 883 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. CONSTANT_TYPE internal static bit(18) initial packed unaligned dcl 3-37 NAME_TYPE internal static bit(18) initial packed unaligned dcl 3-37 OPERATOR_TYPE internal static bit(18) initial packed unaligned dcl 3-37 RUNTIME_ADDRESS_INFO_VERSION_1 internal static char(8) initial packed unaligned dcl 7-128 RUNTIME_SUBRANGE_INFO_VERSION_1 internal static char(8) initial packed unaligned dcl 7-131 RUNTIME_VARIANT_INFO_VERSION_1 internal static char(8) initial packed unaligned dcl 7-130 algol68_array_descriptor_dtype internal static fixed bin(17,0) initial dcl 5-25 algol68_bits_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_bool_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_byte_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_char_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_compl_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_format_dtype internal static fixed bin(17,0) initial dcl 5-25 algol68_int_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_long_compl_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_long_int_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_long_real_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_real_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_short_int_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_straight_dtype internal static fixed bin(17,0) initial dcl 5-25 algol68_struct_struct_bool_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_struct_struct_char_dtype internal static fixed bin(17,0) initial dcl 5-110 algol68_union_dtype internal static fixed bin(17,0) initial dcl 5-25 area_dtype internal static fixed bin(17,0) initial dcl 5-25 arg_desc_type internal static bit(36) initial dcl 10-71 bit_dtype internal static fixed bin(17,0) initial dcl 5-25 bit_type internal static bit(36) initial dcl 10-71 bits_per_binary_exponent 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_packed_ptr internal static fixed bin(31,0) initial dcl 10-5 builtin_type internal static bit(36) initial dcl 10-71 c_enum_const_dtype internal static fixed bin(17,0) initial dcl 5-25 c_enum_dtype internal static fixed bin(17,0) initial dcl 5-25 c_typeref_dtype internal static fixed bin(17,0) initial dcl 5-25 c_union_dtype internal static fixed bin(17,0) initial dcl 5-25 char_type internal static bit(36) initial dcl 10-71 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 cobol_char_string_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_comp_5_ts_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_comp_5_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_comp_6_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_comp_7_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_comp_8_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_comp_8_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_display_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_display_ls_overp_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_display_ts_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_display_ts_overp_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_display_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 cobol_structure_dtype internal static fixed bin(17,0) initial dcl 5-25 complex_type internal static bit(36) initial dcl 10-71 cplx_fix_bin_1_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_fix_bin_2_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_fix_dec_4bit_bytealigned_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_fix_dec_9bit_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_bin_1_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_bin_2_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_bin_generic_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_dec_4bit_bytealigned_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_dec_9bit_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_dec_extended_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_dec_generic_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_hex_1_dtype internal static fixed bin(17,0) initial dcl 5-25 cplx_flt_hex_2_dtype internal static fixed bin(17,0) initial dcl 5-25 current_constant based structure level 1 dcl 3-44 current_identifier_name based char packed unaligned dcl 3-42 current_source based structure level 1 dcl 2-13 current_token based structure level 1 dcl 3-45 dec_integer_type internal static bit(36) initial dcl 10-71 default_area_size internal static fixed bin(31,0) initial dcl 10-5 default_fix_bin_p 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 entry_dtype internal static fixed bin(17,0) initial dcl 5-25 entry_var_type internal static bit(36) initial dcl 10-71 ext_entry_runtime_dtype internal static fixed bin(17,0) initial dcl 5-125 ext_procedure_runtime_dtype internal static fixed bin(17,0) initial dcl 5-125 file_dtype internal static fixed bin(17,0) initial dcl 5-25 ft_char_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_complex_double_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_complex_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_double_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_external_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_hex_complex_double_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_hex_complex_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_hex_double_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_hex_real_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_integer_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_logical_dtype internal static fixed bin(17,0) initial dcl 5-96 ft_real_dtype internal static fixed bin(17,0) initial dcl 5-96 identifier based structure level 1 dcl 3-19 initial_source based structure level 1 dcl 2-14 int_entry_runtime_dtype internal static fixed bin(17,0) initial dcl 5-125 integer_type internal static bit(36) initial dcl 10-71 label_constant_runtime_dtype internal static fixed bin(17,0) initial dcl 5-125 label_dtype internal static fixed bin(17,0) initial dcl 5-25 local_label_var_type internal static bit(36) initial dcl 10-71 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_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_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_length_precision internal static fixed bin(31,0) initial dcl 10-5 max_number_of_dimensions internal static fixed bin(31,0) initial dcl 10-5 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_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 min_area_size internal static fixed bin(31,0) initial dcl 10-5 min_scale internal static fixed bin(31,0) initial dcl 10-5 n_dims automatic fixed bin(17,0) dcl 7-97 n_variants automatic fixed bin(35,0) dcl 7-112 nd automatic fixed bin(6,0) unsigned dcl 9-122 nvariants automatic fixed bin(17,0) dcl 9-121 offset_dtype internal static fixed bin(17,0) initial dcl 5-25 operator based structure level 1 dcl 3-24 packed_digits_per_character internal static fixed bin(31,0) initial dcl 10-5 pascal_address based structure level 1 dcl 9-43 pascal_encoded_value based structure level 1 dcl 9-116 pascal_enumerated_type_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_enumerated_type_element_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_enumerated_type_instance_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_father_brother based structure level 1 dcl 9-51 pascal_father_type_successor based structure level 1 dcl 9-60 pascal_label_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_name_next based structure level 1 dcl 9-35 pascal_offset based fixed bin(35,0) dcl 9-66 pascal_procedure_type_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_record_type_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_set_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_size based fixed bin(35,0) dcl 9-64 pascal_son_level based structure level 1 dcl 9-55 pascal_string_type_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_subrange_limits based structure level 1 dcl 9-68 pascal_typed_pointer_type_dtype internal static fixed bin(17,0) initial dcl 5-132 pascal_variant_info based structure level 1 dcl 9-105 picture_runtime_dtype internal static fixed bin(17,0) initial dcl 5-125 pointer_dtype internal static fixed bin(17,0) initial dcl 5-25 pointer_type internal static bit(36) initial dcl 10-71 probe_area based area(1024) dcl 1-93 probe_info_version internal static fixed bin(17,0) initial dcl 1-88 probe_info_version_1 internal static fixed bin(17,0) initial dcl 1-90 real_fix_bin_1_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_bin_1_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_bin_2_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_bin_2_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_4bit_bytealigned_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_4bit_bytealigned_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_4bit_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_4bit_ts_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_4bit_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_9bit_ls_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_9bit_ls_overp_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_9bit_ts_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_9bit_ts_overp_dtype internal static fixed bin(17,0) initial dcl 5-25 real_fix_dec_9bit_uns_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_bin_1_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_bin_2_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_bin_generic_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_dec_4bit_bytealigned_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_dec_4bit_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_dec_9bit_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_dec_extended_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_dec_generic_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_hex_1_dtype internal static fixed bin(17,0) initial dcl 5-25 real_flt_hex_2_dtype internal static fixed bin(17,0) initial dcl 5-25 real_type internal static bit(36) initial dcl 10-71 reference_arg_list based structure level 1 dcl 4-59 reference_subscripts based structure level 1 dcl 4-64 runtime_address_info based structure level 1 dcl 7-56 runtime_subrange_info based structure level 1 unaligned dcl 7-116 runtime_symbol_info_$address 000000 constant entry external dcl 7-54 runtime_symbol_info_$father 000000 constant entry external dcl 7-38 runtime_symbol_info_$father_type 000000 constant entry external dcl 7-42 runtime_symbol_info_$level 000000 constant entry external dcl 7-50 runtime_symbol_info_$n_variants 000000 constant entry external dcl 7-99 runtime_symbol_info_$next 000000 constant entry external dcl 7-52 runtime_symbol_info_$subrange 000000 constant entry external dcl 7-114 runtime_symbol_info_$successor 000000 constant entry external dcl 7-46 runtime_symbol_info_$variant 000000 constant entry external dcl 7-101 runtime_variant_info based structure level 1 dcl 7-103 scratch_area based area(1024) dcl 1-92 seg_info_nfiles automatic fixed bin(17,0) dcl 8-47 storage_block_type internal static bit(36) initial dcl 10-71 subscript_reference_ptrs based structure level 1 dcl 4-69 varying_bit_dtype internal static fixed bin(17,0) initial dcl 5-25 varying_char_dtype internal static fixed bin(17,0) initial dcl 5-25 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 work_area based area(1024) dcl 1-94 NAMES DECLARED BY EXPLICIT CONTEXT. MAIN_RETURN 005275 constant label dcl 1115 RECORDED_MESSAGE 005302 constant label dcl 1125 ref 166 226 246 252 261 305 342 477 602 635 840 849 SOME_ERROR 005277 constant label dcl 1120 ref 269 438 514 616 643 654 662 737 747 757 833 855 884 910 936 982 987 992 997 1035 1039 1100 1127 allocate_temp 004104 constant entry internal dcl 875 in begin block on line 522 ref 788 809 816 1018 allocate_temp 002161 constant entry internal dcl 503 in begin block on line 171 ref 326 398 434 479 build_descriptor 002035 constant entry internal dcl 449 ref 288 356 common 000356 constant label dcl 134 ref 125 132 convert_units 005166 constant entry internal dcl 1064 ref 1054 decode 004136 constant entry internal dcl 889 ref 776 1050 1052 1054 1054 fill_dim 005043 constant entry internal dcl 1047 ref 1025 1043 invalid_arg_err 002503 constant label dcl 631 ref 665 671 682 697 740 760 797 is_conformant 004215 constant entry internal dcl 916 ref 619 624 is_file 005211 constant entry internal dcl 1086 ref 689 match_arg 001555 constant entry internal dcl 367 ref 272 280 282 284 match_arrays 004320 constant entry internal dcl 944 ref 665 760 999 pass_conf_desc 004661 constant entry internal dcl 1006 ref 668 764 probe_invoke_ 000306 constant entry external dcl 25 probe_invoke_$function 000325 constant entry external dcl 121 probe_invoke_$subroutine 000344 constant entry external dcl 128 units_case 000000 constant label array(0:3) dcl 1072 set ref 1070 wrong_no_arg_err 002337 constant label dcl 599 ref 826 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6032 6132 5413 6042 Length 6612 5413 100 443 416 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME probe_invoke_ 92 external procedure is an external procedure. begin block on line 145 begin block shares stack frame of external procedure probe_invoke_. begin block on line 171 188 begin block uses auto adjustable storage. match_arg internal procedure shares stack frame of begin block on line 171. build_descriptor internal procedure shares stack frame of begin block on line 171. allocate_temp internal procedure shares stack frame of begin block on line 171. begin block on line 522 760 begin block uses auto adjustable storage. allocate_temp internal procedure shares stack frame of begin block on line 522. decode internal procedure shares stack frame of begin block on line 522. is_conformant internal procedure shares stack frame of begin block on line 522. match_arrays 384 internal procedure calls itself recursively. pass_conf_desc internal procedure shares stack frame of begin block on line 522. fill_dim internal procedure shares stack frame of begin block on line 522. convert_units internal procedure shares stack frame of begin block on line 522. is_file internal procedure shares stack frame of begin block on line 522. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 171 000100 desc_origin begin block on line 171 000100 dummy_arg_list begin block on line 171 000100 desc_ptrs begin block on line 171 000101 number_descs begin block on line 171 000102 type begin block on line 171 000103 ndims begin block on line 171 000104 size begin block on line 171 000105 scale begin block on line 171 000106 packed begin block on line 171 000107 match begin block on line 171 000110 must_build begin block on line 171 000112 arg_ref begin block on line 171 000114 i begin block on line 171 000140 tref match_arg 000142 need match_arg 000143 i match_arg 000144 arith_to_char match_arg 000154 dp build_descriptor 000164 p allocate_temp begin block on line 522 000100 f_dims begin block on line 522 000100 dummy_arg_list begin block on line 522 000101 a_dims begin block on line 522 000102 pascal_int_call_op begin block on line 522 000103 pascal_ext_call_op begin block on line 522 000104 pascal_entry_parm_size begin block on line 522 000106 pvalue_ref_ptr begin block on line 522 000110 formal_ptr begin block on line 522 000112 operator_number begin block on line 522 000114 entry_type_info begin block on line 522 000126 fconf_type_info begin block on line 522 000140 arg_ref_ptr begin block on line 522 000142 bit_size begin block on line 522 000144 temp_addr begin block on line 522 000146 i begin block on line 522 000147 total_dims begin block on line 522 000150 formal_is_conformant begin block on line 522 000151 arg_is_conformant begin block on line 522 000152 formal_type_info begin block on line 522 000164 arg_type_info begin block on line 522 000176 formal_array_info begin block on line 522 000402 arg_array_info begin block on line 522 000606 Block_ptr begin block on line 522 000610 Linkage_ptr begin block on line 522 000612 Stack_ptr begin block on line 522 000614 Base_addr begin block on line 522 000616 char_to_array_type begin block on line 522 000644 p allocate_temp 000654 result decode 000672 ai pass_conf_desc 001076 desc_len pass_conf_desc 001077 it pass_conf_desc 001100 count pass_conf_desc 001101 index pass_conf_desc 001102 ti pass_conf_desc 001114 desc_addr pass_conf_desc 001116 tp pass_conf_desc 001156 type_info is_file match_arrays 000100 i match_arrays 000102 ai11 match_arrays 000306 ai12 match_arrays 000512 ti11 match_arrays 000524 ti12 match_arrays probe_invoke_ 000100 function_flag probe_invoke_ 000101 number_args probe_invoke_ 000102 possible_number probe_invoke_ 000104 entry probe_invoke_ 000106 stack_frame probe_invoke_ 000110 code probe_invoke_ 000112 probe_info_ptr probe_invoke_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp enter_begin_block leave_begin_block call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 alloc_auto_adj mpfx2 shorten_stack ext_entry int_entry trunc_fx2 ceil_fx1 divide_fx1 divide_fx3 op_alloc_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cu_$gen_call cu_$grow_stack_frame decode_descriptor_ get_entry_arg_descs_ get_size_in_bits_ pascal_gen_call_ probe_assign_value_ probe_create_reference_ probe_error_$malfunction probe_error_$record probe_pascal_$real_type runtime_symbol_info_$array runtime_symbol_info_$array_dims runtime_symbol_info_$brother runtime_symbol_info_$name runtime_symbol_info_$son runtime_symbol_info_$type stu_$decode_runtime_value_extended THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$lower_ring error_table_$nodescr probe_et_$array_arg probe_et_$bad_return_val probe_et_$int_proc probe_et_$no_return_desc probe_et_$not_function probe_et_$recorded_message probe_et_$struc_arg probe_et_$wrong_no_args LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 25 000305 28 000313 121 000317 124 000335 125 000337 128 000340 131 000354 132 000355 134 000356 140 000362 142 000366 145 000372 148 000376 150 000403 152 000406 153 000411 154 000412 159 000417 160 000421 163 000423 164 000427 166 000450 171 000451 175 000454 218 000474 220 000531 224 000543 226 000573 227 000576 229 000577 232 000601 236 000603 238 000607 240 000613 241 000616 242 000620 243 000621 244 000626 246 000651 250 000654 252 000677 256 000702 257 000711 258 000720 259 000724 261 000745 264 000750 267 000776 268 001000 269 001004 272 001007 275 001016 277 001025 280 001031 281 001033 282 001034 284 001043 287 001054 288 001060 290 001076 291 001110 292 001116 297 001127 299 001131 300 001134 302 001163 303 001170 305 001214 308 001217 309 001245 310 001251 311 001260 312 001262 313 001265 314 001321 315 001323 316 001327 317 001331 323 001345 324 001350 326 001357 328 001370 329 001400 333 001411 336 001420 339 001421 340 001424 342 001447 345 001452 347 001456 348 001461 350 001463 351 001473 352 001502 353 001505 356 001520 357 001534 364 001536 519 001553 367 001555 371 001557 398 001560 400 001564 401 001570 403 001575 404 001600 405 001613 406 001615 408 001620 412 001631 414 001634 415 001636 416 001640 418 001641 420 001651 422 001653 424 001663 425 001670 428 001671 429 001725 431 001730 432 001733 434 001752 436 001762 438 002002 441 002010 442 002012 443 002026 445 002031 446 002034 449 002035 474 002037 475 002044 477 002066 479 002071 482 002075 483 002077 484 002112 485 002117 487 002121 490 002133 492 002144 497 002156 503 002161 513 002163 514 002201 516 002207 145 002213 522 002214 528 002217 538 002236 539 002240 541 002242 577 002244 578 002251 579 002254 580 002257 582 002263 583 002264 584 002266 585 002270 586 002273 587 002275 588 002276 590 002302 591 002304 592 002306 595 002310 597 002322 598 002333 599 002337 602 002363 604 002366 605 002376 606 002401 607 002403 610 002406 612 002411 614 002413 616 002431 619 002437 622 002441 624 002450 626 002464 629 002471 631 002503 635 002543 639 002546 641 002550 643 002566 646 002574 647 002577 649 002600 651 002602 654 002620 658 002626 660 002630 662 002647 665 002655 668 002700 669 002701 671 002702 673 002705 682 002740 688 002753 689 002761 692 002775 693 002776 696 003000 697 003003 699 003006 712 003012 714 003015 718 003025 719 003027 720 003031 721 003033 722 003035 723 003041 724 003043 725 003044 726 003046 727 003050 729 003052 730 003054 731 003056 733 003061 735 003063 737 003101 740 003107 743 003114 745 003116 747 003134 750 003142 752 003143 754 003145 757 003163 760 003171 764 003214 766 003215 767 003227 768 003264 770 003321 771 003324 772 003327 773 003331 776 003340 779 003354 780 003360 783 003371 784 003375 787 003421 788 003423 790 003445 795 003461 797 003477 800 003502 801 003510 802 003511 804 003513 807 003517 809 003523 810 003525 811 003530 812 003533 813 003535 814 003537 815 003540 816 003542 817 003544 818 003547 819 003552 820 003554 822 003556 824 003564 825 003574 826 003601 829 003605 831 003607 833 003627 836 003635 837 003640 838 003643 840 003701 842 003704 844 003721 846 003722 847 003725 849 003760 853 003763 855 004006 858 004014 859 004017 860 004026 861 004031 862 004033 864 004040 866 004045 868 004052 869 004054 870 004056 871 004101 1111 004102 875 004104 883 004106 884 004124 886 004132 889 004136 902 004140 906 004150 910 004203 912 004211 916 004215 925 004217 926 004220 927 004224 931 004235 933 004251 935 004255 936 004273 939 004301 941 004311 944 004317 958 004325 965 004372 969 004401 970 004407 974 004431 976 004436 978 004446 980 004453 981 004455 982 004474 985 004503 986 004505 987 004526 990 004535 991 004537 992 004560 995 004567 996 004571 997 004612 999 004621 1001 004654 1006 004661 1017 004662 1018 004667 1019 004671 1020 004700 1021 004713 1022 004714 1023 004717 1024 004722 1025 004733 1026 004734 1028 004741 1029 004743 1031 004745 1032 004751 1034 004753 1035 004771 1038 004777 1039 005015 1042 005023 1043 005033 1044 005034 1045 005041 1084 005042 1047 005043 1050 005044 1052 005062 1054 005101 1057 005137 1061 005153 1062 005161 1082 005165 1064 005166 1070 005170 1072 005172 1074 005176 1076 005201 1078 005205 1086 005211 1092 005213 1096 005225 1098 005227 1099 005231 1100 005247 1102 005255 1106 005267 1115 005275 1117 005276 1120 005277 1122 005301 1125 005302 1127 005305 ----------------------------------------------------------- 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