COMPILATION LISTING OF SEGMENT amu_parse_ptr_args_ Compiled by: Multics PL/I Compiler, Release 30, of February 16, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 07/12/88 1433.6 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* *********************************************************** */ 8 9 10 /****^ HISTORY COMMENTS: 11* 1) change(86-12-16,Parisek), approve(87-07-09,MCR7746), 12* audit(87-07-17,Fawcett), install(87-07-28,MR12.1-1049): 13* Changed to accept decimal integers with the "-for" control argument 14* instead of accepting only octal values. 15* 2) change(87-01-13,Parisek), approve(87-07-09,MCR7746), 16* audit(87-07-17,Fawcett), install(87-07-28,MR12.1-1049): 17* Correctly interpret arg to the "-pointers" control arg with the "mc" 18* request (phx19327). 19* 3) change(87-02-11,Parisek), approve(87-07-09,MCR7746), 20* audit(87-07-17,Fawcett), install(87-07-28,MR12.1-1049): 21* Determine if referenced segment name is a temp ptr name before 22* attempting to translate it to a segno for reading users deadprocs. 23* 4) change(87-10-29,Parisek), approve(88-03-09,MCR7861), 24* audit(88-07-08,Farley), install(88-07-12,MR12.2-1055): 25* Correct bug in determining temporary pointer values when analyzing 26* dead_procs. 27* 5) change(88-02-22,Parisek), approve(88-03-09,MCR7861), 28* audit(88-07-08,Farley), install(88-07-12,MR12.2-1055): 29* In checking for "ring_N" or "stack_N" segs, make sure there are not more 30* characters in the segment name such as "stack_0_data". We don't want to 31* think stack_0_data is really stack_0. 32* END HISTORY COMMENTS */ 33 34 35 amu_parse_ptr_args_: proc (); 36 37 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 38 39 /* Modified 10 Jan 85 by BLB to correct the check_name procedure to check for 40* non-hardcore names too. 41**/ 42 43 /* Parameters */ 44 45 dcl a_code fixed bin (35); 46 dcl a_segname char(*); 47 dcl segname char(32); 48 dcl segname_entry bit(1) init("0"b); 49 dcl a_nargs fixed bin; 50 dcl a_va char(*); 51 dcl a_amu_info_ptr ptr; 52 dcl a_offset fixed bin (18); 53 dcl a_segno fixed bin; 54 dcl sci_ptr ptr; 55 56 /* Automatic */ 57 58 dcl al fixed bin (21); 59 dcl ap ptr; 60 dcl arg char (al) based (ap); 61 dcl argno fixed bin; 62 dcl code fixed bin (35); 63 dcl doing fixed bin; 64 dcl error_msg char(256) var; 65 dcl 1 hard_ptr_space like hardcore_cur; 66 dcl indirect_sw bit (1); 67 dcl nargs fixed bin; 68 dcl segno fixed bin (17); 69 70 dcl temp_ptr ptr; 71 72 /* External */ 73 74 dcl amu_$definition_ptr entry (ptr, char (*), char (*), fixed bin (35)) returns (ptr); 75 dcl amu_$definition_get_prn entry (ptr, char (*), ptr, fixed bin (35)); 76 dcl amu_$do_translation entry (ptr, fixed bin, ptr, fixed bin (18), fixed bin (18), fixed bin (35)); 77 dcl amu_$dp_name_to_segno entry (ptr, char(*), fixed bin, fixed bin(35)); 78 dcl amu_$fdump_mpt_temp_change_idx entry (ptr, fixed bin); 79 dcl amu_$fdump_mpt_revert_idx entry (ptr); 80 dcl amu_$hardcore_info_set_cur_ptrs entry (ptr, ptr); 81 dcl amu_$return_val_per_process entry (ptr, fixed bin) returns (bit (1)); 82 dcl amu_$slt_search_init_seg_ptr entry (ptr, ptr, char(*), ptr, fixed bin(35)); 83 dcl amu_$slt_search_seg_ptr entry (ptr, ptr, char(*), ptr, fixed bin(35)); 84 dcl (cv_oct_check_, cv_dec_check_) entry (char (*), fixed bin (35)) returns (fixed bin (35)); 85 dcl ioa_$rsnnl entry() options(variable); 86 87 dcl ssu_$arg_ptr entry (ptr, fixed bin, ptr, fixed bin (21)); 88 89 /* Error tables */ 90 91 dcl amu_et_$bad_segno fixed bin (35) ext static; 92 dcl amu_et_$error_indirect fixed bin (35) ext static; 93 dcl amu_et_$invalid_seq fixed bin (35) ext static; 94 dcl amu_et_$negative_offset fixed bin (35) ext static; 95 dcl amu_et_$no_segname fixed bin (35) ext static; 96 dcl amu_et_$no_va_specified fixed bin (35) ext static; 97 dcl amu_et_$not_its_ptr fixed bin (35) ext static; 98 dcl amu_et_$not_octal_offset fixed bin (35) ext static; 99 dcl amu_et_$not_octal_off_mod fixed bin (35) ext static; 100 dcl amu_et_$not_octal_range fixed bin (35) ext static; 101 dcl amu_et_$not_octal_segno fixed bin (35) ext static; 102 dcl amu_et_$null_ptr fixed bin (35) ext static; 103 dcl amu_et_$specified_modifier fixed bin (35) ext static; 104 dcl amu_et_$modifier_before_range fixed bin (35) ext static; 105 dcl error_table_$noentry fixed bin (35) ext static; 106 dcl error_table_$seg_not_found fixed bin (35) ext static; 107 108 dcl (addr, baseno, baseptr, fixed, index, 109 lbound, length, null, rel, rtrim, 110 search, substr, verify) builtin; 111 112 amu_parse_ptr_args_$resolve_va: entry(sci_ptr, a_amu_info_ptr, a_va, a_segno, a_offset, a_code); 113 114 /* This entry resolves the virtual address to its segment number and offset. 115* sci_ptr subsystem pointer (input), 116* a_amu_info_ptr pointer to amu_info structure (input), 117* a_va virtual address construct (input), 118* a_segno segment number (output), 119* a_offset segment offset (output), 120* a_code standadrd error code. 121**/ 122 123 dcl error_found bit(1); 124 125 amu_info_ptr = a_amu_info_ptr; 126 code = 0; 127 va_args_ptr = addr(va_args); 128 va.segno, va.offset, va.offset_modifier, 129 va.range, va.va_position, va.ecode = 0; 130 va.va_switches = "0"b; 131 va.error_msg, va.va_string = ""; 132 va.resolved_va = null(); 133 error_found = "0"b; 134 call get_va(a_va, va_args_ptr, error_found, indirect_sw); 135 if error_found then do; 136 if va.ecode = 0 then va.ecode = amu_et_$invalid_seq; 137 end; 138 else do; 139 if indirect_sw then call resolve_indirection(va_args_ptr, error_found); 140 if error_found then do; 141 if va.ecode = 0 then va.ecode = amu_et_$invalid_seq; 142 end; 143 end; 144 145 a_segno = va.segno; 146 a_offset = va.offset; 147 a_code = va.ecode; 148 return; 149 150 amu_parse_ptr_args_$get_segno: entry(sci_ptr, a_amu_info_ptr, a_segname, a_segno, a_code); 151 152 /* This entry gets the segment number assoctiated with a segment name. 153* sci_ptr subsystem pointer (input), 154* a_amu_info_ptr pointer to amu_info structure (input), 155* a_segname segment name (input), 156* a_segno segment number (output), 157* a_code standadrd error code. 158**/ 159 160 amu_info_ptr = a_amu_info_ptr; 161 segname = ""; 162 segname = a_segname; 163 code = 0; 164 error_msg = ""; 165 call check_name(segname, temp_ptr, error_msg, code); 166 if error_msg ^= "" | code ^= 0 then do; 167 if code ^= 0 then code = amu_et_$no_segname; 168 end; 169 else do; 170 segno = fixed (baseno (temp_ptr), 17); 171 end; 172 173 a_segno = segno; 174 a_code = code; 175 return; 176 177 amu_parse_ptr_args_$get_va_args: entry(sci_ptr, a_amu_info_ptr, a_arg, a_nargs, a_va_args); 178 179 argno = 1; 180 goto COMMON_ARG; 181 182 amu_parse_ptr_args_$get_va_args_given_start: entry(sci_ptr, a_amu_info_ptr, a_arg, a_start_arg, a_nargs, a_va_args); 183 184 argno = a_start_arg; 185 goto COMMON_ARG; 186 187 188 /* These entrypoints check and validates VA related arguments and fill in the appropriate parts of the 189* va_args structure. get_va_args parses the request line, determining the VA, range and offset modifier 190* and fills in the va_args structure. 191* 192* sci_ptr subsystem pointer (input), 193* a_amu_info_ptr pointer to amu_info structure (input), 194* a_arg pointer to the argument list to be examined (input), 195* a_nargs number of arguments in the list (input), 196* a_va_args pointer to va_args structure (input) 197* 198*For the get_va_args_given_start entry: 199* 200* a_start_arg index to which argument to start in the list (input) 201**/ 202 dcl a_arg ptr; 203 dcl a_va_args ptr; 204 dcl a_start_arg fixed bin; 205 206 dcl ( 207 GETTING_VA init(1), 208 GETTING_MODIFIER init(2), 209 GETTING_RANGE init(3), 210 DONE init(4) 211 212 ) fixed bin int static options(constant); 213 dcl NUMBERS char(10) init("0123456789") int static options(constant); 214 dcl forsw bit (1); 215 216 COMMON_ARG: 217 218 amu_info_ptr = a_amu_info_ptr; 219 va_args_ptr = a_va_args; 220 ap = a_arg; 221 nargs = a_nargs; 222 forsw = "0"b; 223 224 doing = GETTING_VA; 225 do while ((argno <= nargs) & (doing ^= DONE)); 226 call ssu_$arg_ptr (sci_ptr, argno, ap, al); 227 if arg = "-for" then forsw = "1"b; 228 call parse_arg(a_va_args, doing, arg, nargs, argno); 229 end; 230 231 if doing = GETTING_VA then do; 232 if va.ecode = 0 then va.ecode = amu_et_$no_va_specified; 233 else if va.ecode = error_table_$noentry then va.ecode = error_table_$seg_not_found; 234 goto ERROR_RETURN; 235 end; 236 else if va.ecode ^= 0 | va.error_msg ^= "" then goto ERROR_RETURN; 237 238 END_GET_VA_ARGS: 239 240 call finish_va_resolution(a_va_args); 241 242 ERROR_RETURN: 243 return; 244 245 bad_segno: proc(segno, ecode) returns(bit(1)); 246 247 dcl segno fixed bin(18); 248 dcl ecode fixed bin(35); 249 dcl max_segno fixed bin (18) int static options (constant) init (4095); 250 251 252 ecode = 0; 253 if segno = fixed (baseno (null ()), 18) then /* null ptr */ 254 ecode = amu_et_$null_ptr; 255 else if segno > max_segno then ecode = amu_et_$bad_segno; 256 else if segno < 0 then ecode = amu_et_$bad_segno; 257 258 return(ecode^=0); 259 260 end bad_segno; 261 262 check_name: 263 proc (segment_name, temp_ptr, error_msg, code); 264 265 dcl code fixed(35); 266 dcl error_msg char(*) var; 267 dcl segment_name char (*); 268 dcl temp_ptr ptr; 269 270 dcl i fixed bin; 271 dcl ignore fixed bin; 272 dcl stack_idx fixed bin; 273 dcl test_name char (32); 274 275 code = 0; 276 error_msg = ""; 277 temp_ptr = null(); 278 test_name = segment_name; 279 hardcore_cur_ptr = addr (hard_ptr_space); 280 if substr (test_name, 1, 5) = "ring_" | substr (test_name, 1, 6) = "stack_" then do; 281 i = search (test_name, "_"); 282 if length (rtrim(test_name)) = (i+1) then do; /* Is there chars after the octal ring_ or stack_ seg 283* */ /* If so, then it's not ring_ or stack_ seg (ie: stack_0_data) */ 284 stack_idx = cv_oct_check_ (substr (test_name, i + 1), code); 285 if code ^= 0 then do; 286 call ioa_$rsnnl ("The ^[ring^;stack^] number is not octal.", error_msg, ignore, (substr(test_name, 1,5) = "ring_")); 287 return; 288 end; 289 else do; 290 if stack_idx < 0 | stack_idx > 7 then do; 291 call ioa_$rsnnl ("The ^[ring^;stack^] specified does not exist.", error_msg, ignore, (substr(test_name, 1,5) = "ring_")); 292 return; 293 end; 294 end; 295 /* appears to be a valid stack_ring so return the pointer to it */ 296 if amu_info.early_dump & stack_idx >0 then do; 297 code = error_table_$seg_not_found; 298 return; 299 end; 300 temp_ptr = baseptr (hardcore_info.segno.stack_0 + stack_idx); 301 return; 302 end; 303 end; 304 305 call amu_$hardcore_info_set_cur_ptrs (amu_info_ptr, hardcore_cur_ptr); 306 call amu_$slt_search_seg_ptr (hardcore_cur.sltp, hardcore_cur.sltntp, test_name, temp_ptr, code); 307 if code ^= 0 then do; 308 if amu_info.early_dump then 309 call amu_$slt_search_init_seg_ptr (hardcore_cur.sltp, hardcore_cur.sltntp, test_name, temp_ptr, code); 310 end; 311 312 if code ^= 0 then do; /* not a hardcore segment name */ 313 dcl segno fixed bin; 314 if amu_info.type = SAVED_PROC_TYPE then do; 315 call amu_$definition_get_prn (amu_info_ptr, test_name, temp_ptr, code); 316 /* see if test_name is a temp ptr */ 317 if code = 0 then do; 318 if temp_ptr = null then do; 319 va.ecode = amu_et_$invalid_seq; 320 call ioa_$rsnnl ("Temporary ptr specified is null. ^a", va.error_msg, ignore, test_name); 321 return; 322 end; 323 else do; 324 call amu_$dp_name_to_segno (amu_info_ptr, test_name, segno, code); 325 if code = 0 then temp_ptr = baseptr(segno); 326 end; 327 end; 328 end; 329 else if amu_info.type = FDUMP_TYPE | amu_info.type = FDUMP_PROCESS_TYPE then do; 330 end; 331 end; 332 333 334 end check_name; 335 336 finish_va_resolution: proc(va_arg_ptr); 337 338 dcl va_arg_ptr ptr; 339 dcl 1 va based(va_arg_ptr) like va_args; 340 341 dcl argl fixed bin (21); 342 dcl argp ptr; 343 dcl arg char (argl) based (argp); 344 345 if bad_segno(va.segno, va.ecode) then do; 346 call ssu_$arg_ptr (sci_ptr, va.va_idx, argp, argl); 347 va.error_msg = arg; 348 goto END_FINISH_VA; 349 end; 350 351 if va.valid_modifier & ^(va.modifier_before_indirect) then do; 352 va.offset = va.offset + va.offset_modifier; 353 if va.offset < 0 then do; 354 va.ecode = amu_et_$negative_offset; 355 va.error_msg = va.va_string; 356 goto END_FINISH_VA; 357 end; 358 end; 359 360 /* RIGHT HERE must check the final segno|offset to see if its in the fdump */ 361 362 END_FINISH_VA: 363 364 return; 365 end finish_va_resolution; 366 367 get_indirect_ptr: 368 proc (data_ptr, seg, word, number, code); 369 370 /* Given a data_ptr to put it, returns the address area specified by seg, word, number. 371* 372* data_ptr pointer to put data at (input) 373* seg segment number (input) 374* word word offset (input) 375* number range (input) 376* code error code (output) 377**/ 378 379 /* parameters */ 380 381 dcl code fixed bin(35); 382 dcl data_ptr ptr; 383 dcl seg fixed bin; 384 dcl (word, number) fixed bin (18); 385 386 /* automatic */ 387 388 dcl index_changed bit(1); 389 390 index_changed = "0"b; 391 code = 0; 392 if ^amu_$return_val_per_process (amu_info_ptr, seg) then do; 393 index_changed = "1"b; 394 call amu_$fdump_mpt_temp_change_idx (amu_info_ptr, lbound (fdump_process_table.array, 1)); 395 end; 396 397 call amu_$do_translation (amu_info_ptr, seg, data_ptr, word, number, code); 398 399 if index_changed then do; 400 call amu_$fdump_mpt_revert_idx (amu_info_ptr); 401 index_changed = "0"b; 402 end; 403 404 end get_indirect_ptr; 405 406 get_va: 407 proc (pointer_arg, va_arg_ptr, error_found, indirect_specified); 408 409 /* parameters */ 410 411 dcl error_found bit(1); 412 dcl indirect_specified bit(1); 413 dcl pointer_arg char(*); 414 dcl pointer_arg_length fixed bin; 415 dcl va_arg_ptr ptr; 416 417 /* based */ 418 419 dcl 1 va based(va_arg_ptr) like va_args; 420 421 /* automatic */ 422 423 dcl code fixed bin(35); 424 dcl ignore fixed bin; 425 dcl (ind_pos, offset_pos) fixed bin; 426 dcl offset fixed bin (18); 427 dcl offset_modifier char(32); 428 dcl offset_name char (65); 429 dcl mod_pos fixed bin; 430 dcl seg_name char (32); 431 dcl segno fixed bin; 432 dcl segno_given bit(1); 433 dcl temp_ptr ptr; 434 dcl temp_ptr_given bit(1); 435 dcl two_parts bit(1); 436 dcl va_arg char(256) var; 437 438 /* First check to see if the assumed VA is in two parts (A$B or A|B forms) */ 439 440 code = 0; 441 error_found, two_parts, indirect_specified, temp_ptr_given, segno_given = "0"b; 442 pointer_arg_length = length(pointer_arg); 443 ind_pos = index(pointer_arg, ",*"); /* is this indirect? */ 444 mod_pos = search (pointer_arg, "+-"); /* do we have a offset modifier */ 445 offset_pos = search (pointer_arg, "$|"); /* is arg in two parts? */ 446 two_parts = (offset_pos > 0); 447 indirect_specified = (ind_pos > 0); 448 449 va_arg = pointer_arg; 450 if mod_pos > 0 then do; 451 if mod_pos < ind_pos then do; /* have case of form A|B+30,* */ 452 offset_modifier = substr(pointer_arg, mod_pos, (pointer_arg_length - (mod_pos + 1))); 453 va_arg = substr(pointer_arg, 1, mod_pos - 1); 454 va.modifier_before_indirect = "1"b; 455 end; 456 else do; /* have case A|B,*+30 or A|B+30 */ 457 offset_modifier = substr(pointer_arg, mod_pos); 458 if indirect_specified then 459 va_arg = substr(pointer_arg, 1, ind_pos - 1); /* case A|B,*+10 */ 460 else va_arg = substr(pointer_arg, 1, mod_pos - 1); /* case A|B+10 */ 461 end; 462 463 /* lets verify the modifier */ 464 465 va.offset_modifier = cv_oct_check_ (offset_modifier, code); 466 if code = 0 then va.valid_modifier = "1"b; 467 else do; 468 va.offset_modifier = 0; 469 error_found = "1"b; 470 va.ecode = amu_et_$not_octal_off_mod; 471 va.error_msg = offset_modifier; 472 goto END_GET_VA; 473 end; 474 end; /* end if mod_pos > 0 */ 475 476 else if indirect_specified then 477 va_arg = substr(pointer_arg, 1, ind_pos - 1); /* case A|B,* */ 478 479 if two_parts then do; 480 seg_name = substr(va_arg, 1, offset_pos - 1); 481 offset_name = substr(va_arg, (offset_pos + 1)); 482 end; 483 else do; 484 if indirect_specified then seg_name = substr(va_arg, 1, ind_pos - 1); 485 else seg_name = va_arg; 486 end; 487 488 /* is seg_name a name, number or temporary ptr? */ 489 490 va.offset = 0; 491 va.segno = 0; 492 code = 0; 493 segno = cv_oct_check_ (seg_name, code); /* check to see if its a name or number */ 494 if code = 0 then do; /* yep, it's octal */ 495 segno_given = "1"b; 496 va.segno = segno; 497 va.valid_va = "1"b; 498 end; 499 500 else do; /* not an octal number */ 501 if verify(rtrim(seg_name), NUMBERS) = 0 then do; 502 error_found = "1"b; 503 va.ecode = amu_et_$not_octal_segno; 504 va.error_msg = rtrim(seg_name); 505 goto END_GET_VA; 506 end; 507 508 code = 0; 509 call check_name(seg_name, temp_ptr, va.error_msg, code); 510 if va.error_msg ^= "" then do; /* invalid stack_N or ring_N name */ 511 error_found = "1"b; 512 if va.ecode = amu_et_$invalid_seq then goto END_GET_VA; 513 va.ecode = amu_et_$not_octal_segno; 514 va.error_msg = va.error_msg || " " || rtrim(seg_name); 515 goto END_GET_VA; 516 end; 517 else do; 518 if code = 0 then do; /* yep, it's a name */ 519 va.segno = fixed (baseno (temp_ptr), 17); 520 va.valid_va = "1"b; 521 end; 522 523 else do; /* not a segment name */ 524 /* check to see if it's a temporary pointer */ 525 code = 0; 526 call amu_$definition_get_prn (amu_info_ptr, seg_name, temp_ptr, code); 527 if code = 0 then do; /* yep, it's a temporary pointer */ 528 if temp_ptr = null then do; /* but it's null so quit here */ 529 error_found = "1"b; 530 va.ecode = amu_et_$invalid_seq; 531 call ioa_$rsnnl ("Temporary ptr specified is null. ^a", va.error_msg, ignore, seg_name); 532 goto END_GET_VA; 533 end; 534 va.segno = fixed (baseno (temp_ptr), 17); 535 va.offset = fixed (rel (temp_ptr), 18); 536 va.valid_va = "1"b; 537 temp_ptr_given = "1"b; 538 end; 539 540 else do; /* not a temporatry pointer either */ 541 542 if two_parts then; /* segno|offset may be valid continue checking */ 543 else goto END_GET_VA; /* could be an arg not part of the VA construct, so just skip it */ 544 end; 545 end; 546 end; 547 end; 548 549 if two_parts then do; /* given an offset too */ 550 offset = cv_oct_check_ (offset_name, code); 551 if code = 0 then do; 552 va.offset = va.offset + offset; 553 va.valid_va = "1"b; 554 end; 555 else do; /* check to see if offset is a name */ 556 if verify(rtrim(offset_name), NUMBERS) = 0 then do; 557 error_found = "1"b; 558 va.ecode = amu_et_$not_octal_offset; 559 va.error_msg = offset_name; 560 goto END_GET_VA; 561 end; 562 563 if segno_given then do; /* invalid case of segno|name */ 564 va.ecode = amu_et_$invalid_seq; 565 va.error_msg = "A virtual address number|name is not valid."; 566 error_found = "1"b; 567 goto END_GET_VA; 568 end; 569 570 else do; /* both seg and offset are names, check to see if it's a symbol */ 571 if temp_ptr_given then do; 572 va.offset = va.offset + offset; 573 va.valid_va = "1"b; 574 end; 575 else do; 576 temp_ptr = amu_$definition_ptr (amu_info_ptr, seg_name, offset_name, code); 577 if code = 0 then do; /* a symbol */ 578 va.segno = fixed (baseno (temp_ptr), 17); 579 va.offset = fixed (rel (temp_ptr), 18); 580 va.valid_va = "1"b; 581 end; 582 else do; 583 error_found = "1"b; 584 va.ecode = amu_et_$invalid_seq; 585 va.error_msg = "This is not a valid symbol." || " " || arg; 586 goto END_GET_VA; 587 end; 588 end; 589 end; 590 end; 591 end; 592 593 END_GET_VA: 594 595 return; 596 end get_va; 597 598 parse_arg: proc(p_va_args, doing, arg, nargs, arg_position); 599 600 /* parse_arg 601* 602* p_va_args pointer to the va_args structure(input) 603* parse_arg fills this in. 604* doing where we are in the parsing sequnce(input) 605* parse_arg resets this. 606* arg argument to be parsed (input) 607* nargs total args in the list (input) 608* arg_position the arg list index (input) 609* parse_arg sets the index to the next arg position to examine 610* 611* The virtual address, offset modifer and range are non-positional arguments in the arg list. A virtual 612* address must be specified. A modifier or range are optional. A virtual address must be specified 613* before an offset modifier can be specified on the arg list. An offset modifier must be specified 614* before a range can be specified. This is similar to how the dump_segment command parses its args. 615**/ 616 617 /* parameters */ 618 619 dcl arg char (*); 620 dcl arg_position fixed bin; 621 dcl doing fixed bin; 622 dcl nargs fixed bin; 623 dcl p_va_args ptr; 624 625 /* automatic */ 626 627 dcl code fixed bin(35); 628 dcl error_found bit(1); 629 dcl ignore fixed bin; 630 dcl indirection_specified bit(1); 631 dcl offset fixed bin(18); 632 633 code = 0; 634 error_found, indirection_specified = "0"b; 635 636 if doing = GETTING_VA then do; 637 if arg = "-prs" then do; 638 doing = DONE; 639 goto RETURN_PARSE_ARG; 640 end; 641 else if substr(arg,1,1) = "-" then goto RETURN_PARSE_ARG; /* assume it's a ctl arg */ 642 va.va_string = arg; 643 call get_va(arg, p_va_args, error_found, indirection_specified); 644 if error_found then do; 645 doing = DONE; /* quit processing */ 646 goto RETURN_PARSE_ARG; 647 end; 648 if va.valid_va then do; 649 if indirection_specified then call resolve_indirection (p_va_args, error_found); 650 if error_found then do; 651 doing = DONE; /* quit processing */ 652 goto RETURN_PARSE_ARG; 653 end; 654 if va.valid_modifier then doing = GETTING_RANGE; 655 else doing = GETTING_MODIFIER; 656 va.va_idx = arg_position; 657 end; 658 end; /* if GETTING_VA */ 659 660 else if doing = GETTING_MODIFIER then do; 661 if substr(arg,1,1) = "+" then do; /* assume its a offset modifier */ 662 if va.valid_range then do; 663 va.error_msg = arg; 664 /* offset modifier has to specified before a range... */ 665 if va.valid_modifier then va.ecode = amu_et_$specified_modifier; 666 else va.ecode = amu_et_$modifier_before_range; 667 goto RETURN_PARSE_ARG; 668 end; 669 670 offset = cv_oct_check_ (arg, code); 671 if code = 0 then do; 672 va.va_string = va.va_string || " " || arg; 673 va.offset_modifier = offset; 674 va.valid_modifier = "1"b;; 675 va.mod_idx = arg_position; 676 doing = GETTING_RANGE; 677 goto RETURN_PARSE_ARG; 678 end; 679 else do; /* invalid modifier */ 680 doing = DONE; /* quit processing */ 681 va.ecode = amu_et_$not_octal_off_mod; 682 va.error_msg = arg; 683 goto RETURN_PARSE_ARG; 684 end; 685 end; 686 else if substr(arg,1,1) = "-" then do; /* assume its a offset modifier */ 687 offset = cv_oct_check_ (arg, code); 688 if code = 0 then do; 689 if va.valid_range then do; 690 va.error_msg = arg; 691 /* but modifiers have to specified before a range... */ 692 if va.valid_modifier then va.ecode = amu_et_$specified_modifier; 693 else va.ecode = amu_et_$modifier_before_range; 694 goto RETURN_PARSE_ARG; 695 end; 696 697 va.offset_modifier = offset; 698 va.valid_modifier = "1"b;; 699 va.va_string = va.va_string || " " || arg; 700 va.mod_idx = arg_position; 701 doing = GETTING_RANGE; 702 goto RETURN_PARSE_ARG; 703 end; 704 else do; /* Could be a control argument, so skip */ 705 goto RETURN_PARSE_ARG; 706 end; 707 end; 708 else do; /* no + or -, could be a range */ 709 doing = GETTING_RANGE; 710 arg_position = arg_position - 1; 711 goto RETURN_PARSE_ARG; 712 end; 713 end; /* end if getting_modifier */ 714 715 else if doing = GETTING_RANGE then do; 716 if substr(arg,1,1) = "+" then do; /* assume its a offset modifier */ 717 doing = DONE; /* quit processing */ 718 if va.valid_modifier then 719 /* could only get here if modifier was part of the VA eg. 234|2000+20 */ 720 va.ecode = amu_et_$specified_modifier; 721 else /* this should never happen, but it's here for completeness. */ 722 va.ecode = amu_et_$modifier_before_range; 723 va.error_msg = arg; 724 goto RETURN_PARSE_ARG; 725 end; /* if "+" */ 726 727 else if substr(arg,1,1) = "-" then do; /* could be a ctl arg, or error offset modifier */ 728 if verify(arg, NUMBERS) = 0 then do; /* looks like a offset modifier */ 729 doing = DONE; /* quit processing */ 730 if va.valid_modifier then 731 /* could only get here if modifier was part of the VA eg. 234|2000+20 */ 732 va.ecode = amu_et_$specified_modifier; 733 else /* modifier has to be specified before a range... */ 734 va.ecode = amu_et_$modifier_before_range; 735 va.error_msg = arg; 736 end; /* if verify */ 737 goto RETURN_PARSE_ARG; 738 end; /* if "-" */ 739 else do; /* probably a range */ 740 if forsw then do; 741 forsw = "0"b; 742 offset = cv_dec_check_ (arg, code); 743 if code ^= 0 then do; 744 call ioa_$rsnnl ("Decimal integer not supplied with ""-for"": ^a", va.error_msg, ignore, arg); 745 error_found = "1"b; 746 goto RETURN_PARSE_ARG; 747 end; 748 else goto fill_va; 749 end; 750 offset = cv_oct_check_ (arg, code); 751 if code = 0 then do; /* assume its a range */ 752 fill_va: va.range = offset; 753 va.range_idx = arg_position; 754 va.valid_range = "1"b; 755 va.va_string = va.va_string || " " || arg; 756 if arg_position < nargs then 757 doing = GETTING_MODIFIER; /* for error checking purposes. */ 758 else doing = DONE; /* completely done parsing the VA args */ 759 goto RETURN_PARSE_ARG; 760 end; 761 else do; 762 if verify(arg, NUMBERS) = 0 then do; 763 va.ecode = amu_et_$not_octal_range; 764 va.error_msg = arg; 765 error_found = "1"b; 766 end; 767 else do; 768 if arg = ",*" then do; 769 va.ecode = amu_et_$error_indirect; 770 call ioa_$rsnnl ("^/^-For example: ^a^a", va.error_msg, ignore, va.va_string, arg); 771 error_found = "1"b; 772 end; 773 else; /* Could be a control argument, so skip */ 774 end; 775 goto RETURN_PARSE_ARG; 776 end; 777 end; 778 end; /* if getting_range */ 779 780 RETURN_PARSE_ARG: 781 782 arg_position = arg_position + 1; 783 784 return; 785 end parse_arg; 786 787 resolve_indirection: proc (va_arg_ptr, error_found); 788 789 /* This procedure resolves indirection of the specified virtual address. 790* 791* va_arg_ptr pointer to the va_args structure (input) 792* error_found set to on if any errors are found (output) 793* 794**/ 795 796 /* parameters */ 797 798 dcl error_found bit(1); 799 dcl va_arg_ptr ptr; 800 801 /* based */ 802 803 dcl 1 va based(va_arg_ptr) like va_args; 804 805 /* automatic */ 806 807 dcl data_buf_ptr ptr; 808 dcl indirect_ptr ptr; 809 dcl offset fixed bin(18); 810 811 812 error_found = "0"b; 813 offset = va.offset; 814 if va.modifier_before_indirect then do; 815 offset = va.offset + va.offset_modifier; 816 if offset < 0 then do; 817 error_found = "1"b; 818 va.ecode = amu_et_$negative_offset; 819 va.error_msg = va.va_string; 820 goto END_RESOLVE; 821 end; 822 end; 823 824 if bad_segno(va.segno, va.ecode) then do; 825 error_found = "1"b; 826 va.error_msg = va.va_string; 827 goto END_RESOLVE; 828 end; 829 830 data_buf_ptr = addr(indirect_ptr); 831 832 call get_indirect_ptr (data_buf_ptr, (va.segno), offset, (2), va.ecode); 833 if va.ecode ^= 0 then do; 834 error_found = "1"b; 835 va.error_msg = va.va_string; 836 goto END_RESOLVE; 837 end; 838 839 if data_buf_ptr -> its.its_mod = ITS_MODIFIER then do; 840 va.segno = fixed (baseno (indirect_ptr), 17); 841 va.offset = fixed (rel (indirect_ptr), 18); 842 843 if bad_segno(va.segno, va.ecode) then do; 844 error_found = "1"b; 845 va.error_msg = va.va_string; 846 goto END_RESOLVE; 847 end; 848 end; 849 else do; /* not ITS pointer */ 850 /* ignore for now */ 851 error_found = "1"b; 852 va.error_msg = va.va_string; 853 va.ecode = amu_et_$not_its_ptr; 854 goto END_RESOLVE; 855 end; 856 857 END_RESOLVE: 858 return; 859 end resolve_indirection; 860 1 1 /* BEGIN INCLUDE FILE amu_hardcore_info.incl.pl1 */ 1 2 1 3 /* This structure contains information about the hardcore supervisor address 1 4* space for an address translation. */ 1 5 1 6 dcl 1 hardcore_info aligned based (amu_info.hardcore_info_ptr), 1 7 1 8 2 pointers, /* assorted pointers to various useful items */ 1 9 3 slt aligned, /* SLT */ 1 10 4 fptr pointer unaligned, /* address in foreign address space */ 1 11 4 lptr pointer unaligned, /* location in local address space */ 1 12 3 sltnt aligned like hardcore_info.slt, /* SLT names segment */ 1 13 3 definitions aligned like hardcore_info.slt, /* hardcore definitions_ segment */ 1 14 1 15 3 sst aligned like hardcore_info.slt, /* SST */ 1 16 3 tc_data aligned like hardcore_info.slt, /* TC_DATA */ 1 17 3 sstnt aligned like hardcore_info.slt, /* SSTNT (if any -- foreign_ptr = null if not) */ 1 18 3 upt aligned like hardcore_info.slt, /* unpaged_page_tables (if any -- foreign_ptr = null if not) */ 1 19 1 20 2 segno, /* segment numbers of various per-process/per-processor segs */ 1 21 3 prds fixed bin (15), /* segno of PRDS */ 1 22 3 dseg fixed bin (15), /* DSEG */ 1 23 3 pds fixed bin (15), /* PDS */ 1 24 3 kst fixed bin (15), /* KST */ 1 25 3 stack_0 fixed bin (15), /* segno of stack_0 -- first one in stack group */ 1 26 3 unpaged_page_tables fixed bin(15), /* segno of unpaged_page_tables if it exists */ 1 27 1 28 2 apt, /* information about the APT */ 1 29 3 foreign_ptr pointer unaligned, /* foreign and local pointers to tcm.apt */ 1 30 3 local_ptr pointer unaligned, 1 31 3 count fixed bin, /* number of APTEs */ 1 32 3 size fixed bin, /* size of a single APTE */ 1 33 1 34 2 hcs_count fixed bin, /* highest hardcore segno */ 1 35 1 36 2 pad1 fixed bin; 1 37 1 38 dcl hardcore_cur_ptr ptr; 1 39 1 40 dcl 1 hardcore_cur based (hardcore_cur_ptr), 1 41 2 sltp ptr, 1 42 2 sltntp ptr, 1 43 2 defp ptr, 1 44 2 sstp ptr, 1 45 2 tc_datap ptr, 1 46 2 sstntp ptr, 1 47 2 uptp ptr; 1 48 1 49 1 50 1 51 1 52 /* END INCLUDE FILE amu_hardcore_info.incl.pl1 */ 861 862 2 1 /* BEGIN INCLUDE FILE amu_fdump_info.incl.pl1 */ 2 2 2 3 dcl 1 fdump_info aligned based (amu_info.fdump_info_ptr), 2 4 2 version char (8), 2 5 2 ref_count fixed bin, /* number of initiations */ 2 6 2 7 2 erf_name char (32), /* ERF name for this dump */ 2 8 2 dump_dname char (168), /* location of the dump */ 2 9 2 dump_ename char (32), /* ename of component zero */ 2 10 2 system_id char (8), /* the system_id of this erf */ 2 11 2 version_id char (8), /* the version id of this erf */ 2 12 2 dump_seg_0_uid bit (36) aligned, /* for determining EQ-ness and gullibility checking */ 2 13 2 14 2 n_dump_segs fixed bin, /* number of real segs in the dump */ 2 15 2 copy_block_ptr pointer, /* pointer to chain of temp segment blocks */ 2 16 2 17 2 dump_seg_ptr (0:31) pointer, /* pointer and length arrays */ 2 18 2 dump_seg_lth (0:31) fixed bin (18), 2 19 2 20 2 fdump_process_table_ptr pointer; /* pointer to array describing processes */ 2 21 2 22 2 23 dcl 1 fdump_process_table aligned based (fdump_info.fdump_process_table_ptr), 2 24 2 size fixed bin, /* number of entries */ 2 25 2 26 2 array (0:alloc_fdump_process_table_size - 1 refer (fdump_process_table.size)) like fp_table; 2 27 2 28 dcl 1 fp_table based (fp_table_ptr), 2 29 2 first_seg fixed bin, 2 30 2 last_seg fixed bin, 2 31 2 process_info_ptr pointer unaligned, /* pointer to process_info structure, if filled in */ 2 32 2 dmp_seg_indx fixed bin, /* dump seg index where process can be found */ 2 33 2 dmp_seg_offset fixed bin (24), /* offset in the segment refered to by dmp_seg_indx where process starts */ 2 34 2 cpu_name char (1), 2 35 2 dbr fixed bin (24), /* address portion of DBR */ 2 36 2 apte_offset fixed bin (18); 2 37 2 38 dcl fp_table_ptr ptr; 2 39 2 40 dcl alloc_fdump_process_table_size fixed bin; 2 41 2 42 dcl AMU_FDUMP_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_erf1"); 2 43 dcl AMU_FDUMP_INFO_VERSION char (8) internal static options (constant) init ("amu_erf1"); 2 44 2 45 /* END INCLUDE FILE amu_fdump_info.incl.pl1 */ 863 864 3 1 /* BEGIN INCLUDE FILE amu_info.incl.pl1 */ 3 2 3 3 dcl 1 amu_info aligned based (amu_info_ptr), 3 4 2 version char (8) aligned, /* AMU_INFO_VERSION */ 3 5 2 flags aligned, 3 6 3 early_dump bit(1) unal, 3 7 3 pad bit(35) unal, 3 8 2 type fixed bin unal, /* One of the types below */ 3 9 2 time_created fixed bin (71) aligned, /* time created -- for debugging purposes */ 3 10 2 chain, /* a chain of all the amu_info's which exist */ 3 11 3 prev pointer unaligned, 3 12 3 next pointer unaligned, 3 13 3 14 2 area_ptr pointer, /* pointer to area used for allocating things */ 3 15 3 16 2 translation_table_ptr pointer, /* pointer to address map -- always present */ 3 17 /* SEE: amu_translation.incl.pl1 */ 3 18 2 fdump_info_ptr pointer, 3 19 /* pointer to FDUMP info, present if looking at an FDUMP */ 3 20 /* SEE: amu_fdump_info.incl.pl1 */ 3 21 /* old_uid_table pointer if looking at a SAVED PROC. */ 3 22 /* See: amu_old_uid_table */ 3 23 3 24 3 25 2 hardcore_info_ptr pointer, /* pointer to hardcore information -- always present */ 3 26 /* SEE: amu_hardcore_info.incl.pl1 */ 3 27 2 copy_chain pointer, /* pointer to info about segment copies */ 3 28 /* SEE: amu_copy_info.incl.pl1 */ 3 29 2 process_info_ptr pointer, /* pointer to process info for this translation */ 3 30 /* SEE: amu_process_info.incl.pl1 */ 3 31 2 process_idx fixed bin, /* index of process in translation-specifc process table */ 3 32 3 33 2 proc_idx_hold fixed bin, /* a place to keep the index when a changing to another proc */ 3 34 3 35 2 error_info, /* various info about how amu_error_ is to behave */ 3 36 3 error_flags aligned, 3 37 4 handler_exists bit (1) unaligned, /* set to indicate existence of an amu_error handler */ 3 38 4 in_subsystem bit (1) unaligned, /* This amu_info belongs to an ssu_ maintained subsystem */ 3 39 4 pad bit (34) unaligned, 3 40 3 sci_ptr pointer, /* sci_ptr for subsystem, if in_subsystem = "1"b */ 3 41 2 definitions_info_ptr ptr; 3 42 3 43 dcl amu_area area based (amu_info.area_ptr); 3 44 3 45 dcl amu_info_ptr pointer; 3 46 3 47 dcl (FDUMP_TYPE init (1037), /* the various legitimate types of amu_info's */ 3 48 FDUMP_PROCESS_TYPE init (1038), 3 49 ONLINE_TYPE init (1039), 3 50 ONLINE_PROCESS_TYPE init (1040), 3 51 NETWORK_FDUMP_TYPE init (1041), 3 52 NETWORK_ONLINE_TYPE init (1042), 3 53 SAVED_PROC_TYPE init (1043), 3 54 INDIRECT_TYPE init (1044)) fixed bin internal static options (constant); 3 55 3 56 dcl AMU_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_v1"); 3 57 dcl AMU_INFO_VERSION char (8) internal static options (constant) init ("amu_v1"); 3 58 dcl AMU_INFO_VERSION_2 char (8) internal static options (constant) init ("amu_v2"); 3 59 3 60 dcl PDIR_SUFFIX char(4) init("pdir") int static options(constant); 3 61 3 62 /* END INCLUDE FILE amu_info.incl.pl1 */ 865 866 4 1 /* BEGIN INCLUDE FILE its.incl.pl1 4 2* modified 27 July 79 by JRDavis to add its_unsigned 4 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 4 4 4 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 4 6 2 pad1 bit (3) unaligned, 4 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 4 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 4 9 2 pad2 bit (9) unaligned, 4 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 4 11 4 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 4 13 2 pad3 bit (3) unaligned, 4 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 4 15 2 pad4 bit (3) unaligned, 4 16 2 mod bit (6) unaligned; /* further modification */ 4 17 4 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 4 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 4 20 2 pad1 bit (27) unaligned, 4 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 4 22 4 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 4 24 2 pad2 bit (3) unaligned, 4 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 4 26 2 pad3 bit (3) unaligned, 4 27 2 mod bit (6) unaligned; /* further modification */ 4 28 4 29 4 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 4 31 2 pad1 bit (3) unaligned, 4 32 2 segno fixed bin (15) unsigned unaligned, 4 33 2 ringno fixed bin (3) unsigned unaligned, 4 34 2 pad2 bit (9) unaligned, 4 35 2 its_mod bit (6) unaligned, 4 36 4 37 2 offset fixed bin (18) unsigned unaligned, 4 38 2 pad3 bit (3) unaligned, 4 39 2 bit_offset fixed bin (6) unsigned unaligned, 4 40 2 pad4 bit (3) unaligned, 4 41 2 mod bit (6) unaligned; 4 42 4 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 4 44 2 pr_no fixed bin (3) unsigned unaligned, 4 45 2 pad1 bit (27) unaligned, 4 46 2 itp_mod bit (6) unaligned, 4 47 4 48 2 offset fixed bin (18) unsigned unaligned, 4 49 2 pad2 bit (3) unaligned, 4 50 2 bit_offset fixed bin (6) unsigned unaligned, 4 51 2 pad3 bit (3) unaligned, 4 52 2 mod bit (6) unaligned; 4 53 4 54 4 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 4 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 4 57 4 58 /* END INCLUDE FILE its.incl.pl1 */ 867 868 5 1 /* START OF: azm_va_args.incl.pl1 * * * * * * * * * * * * * * * * */ 5 2 5 3 /* This is a structure for argument processing of virtual addresses (VAs) and its related arguments. 5 4* These related arguments can be a an offset modifier EXP which can be a positive or negative 5 5* octal number and a RANGE can be specified. Both EXP and RANGE are optional arguments. The VA 5 6* must always be specified. These three args are non-positional on the request line but there 5 7* is an implicit order among the three. The first non-control argument on the request line must be 5 8* a VA. The second non-control argument on the request line can be a EXP or a RANGE. If it is a 5 9* RANGE then an EXP cannot be specified. In other words, a EXP must follow a VA. 5 10**/ 5 11 5 12 /* Created: 22 MAY 84 by BLB */ 5 13 5 14 dcl 1 va_args aligned, 5 15 /* fully resolved segment number of the virtual address */ 5 16 2 segno fixed bin (18) aligned, 5 17 /* fully resolved offset of the virtual address */ 5 18 2 offset fixed bin(18) unaligned, 5 19 /* offset modifier (+N, -N) of the virtual address */ 5 20 2 offset_modifier fixed bin(18), 5 21 /* The range of the addr area specified */ 5 22 2 range fixed bin(18) unaligned, 5 23 2 va_switches unaligned, 5 24 3 valid_va bit (1) unaligned, /* on if valid virtual address */ 5 25 3 valid_modifier bit (1) unaligned, /* on if valid offset modifier */ 5 26 3 valid_range bit (1) unaligned, /* on if valid range */ 5 27 3 modifier_before_indirect bit(1) unaligned, /* on if the offset modifier is specified */ 5 28 /* before indirection eg. A|B+10,* */ 5 29 3 va_pad bit (32) unaligned, /* must be zero */ 5 30 2 va_position aligned, /* index into the argument list for: */ 5 31 3 va_idx fixed bin, /* virtual address */ 5 32 3 mod_idx fixed bin, /* the offset modifier index */ 5 33 3 range_idx fixed bin, /* the range argument index */ 5 34 2 resolved_va ptr, /* The resolved virtual address */ 5 35 2 ecode fixed bin(35), /* error code */ 5 36 2 error_msg char(80) var, /* error message */ 5 37 2 va_string char(256) var; /* The complete virtual address after parsing thru the args. */ 5 38 5 39 dcl 1 va based (va_args_ptr) like va_args; 5 40 dcl va_args_ptr ptr; 5 41 5 42 /* END OF: azm_va_args.incl.pl1 * * * * * * * * * * * * * * * * */ 869 870 871 872 end amu_parse_ptr_args_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/12/88 1433.6 amu_parse_ptr_args_.pl1 >spec>install>1055>amu_parse_ptr_args_.pl1 861 1 11/20/84 0854.8 amu_hardcore_info.incl.pl1 >ldd>include>amu_hardcore_info.incl.pl1 863 2 09/22/83 1102.5 amu_fdump_info.incl.pl1 >ldd>include>amu_fdump_info.incl.pl1 865 3 11/20/84 0856.1 amu_info.incl.pl1 >ldd>include>amu_info.incl.pl1 867 4 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.incl.pl1 869 5 11/20/84 0854.8 azm_va_args.incl.pl1 >ldd>include>azm_va_args.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. DONE constant fixed bin(17,0) initial dcl 206 ref 225 638 645 651 680 717 729 758 FDUMP_PROCESS_TYPE constant fixed bin(17,0) initial dcl 3-47 ref 329 FDUMP_TYPE constant fixed bin(17,0) initial dcl 3-47 ref 329 GETTING_MODIFIER constant fixed bin(17,0) initial dcl 206 ref 655 660 756 GETTING_RANGE constant fixed bin(17,0) initial dcl 206 ref 654 676 701 709 715 GETTING_VA constant fixed bin(17,0) initial dcl 206 ref 224 231 636 ITS_MODIFIER constant bit(6) initial packed unaligned dcl 4-55 ref 839 NUMBERS 000000 constant char(10) initial packed unaligned dcl 213 ref 501 556 728 762 SAVED_PROC_TYPE constant fixed bin(17,0) initial dcl 3-47 ref 314 a_amu_info_ptr parameter pointer dcl 51 ref 112 125 150 160 177 182 216 a_arg parameter pointer dcl 202 ref 177 182 220 a_code parameter fixed bin(35,0) dcl 45 set ref 112 147* 150 174* a_nargs parameter fixed bin(17,0) dcl 49 ref 177 182 221 a_offset parameter fixed bin(18,0) dcl 52 set ref 112 146* a_segname parameter char packed unaligned dcl 46 ref 150 162 a_segno parameter fixed bin(17,0) dcl 53 set ref 112 145* 150 173* a_start_arg parameter fixed bin(17,0) dcl 204 ref 182 184 a_va parameter char packed unaligned dcl 50 set ref 112 134* a_va_args parameter pointer dcl 203 set ref 177 182 219 228* 238* addr builtin function dcl 108 ref 127 279 830 al 000111 automatic fixed bin(21,0) dcl 58 set ref 226* 227 228 228 585 amu_$definition_get_prn 000012 constant entry external dcl 75 ref 315 526 amu_$definition_ptr 000010 constant entry external dcl 74 ref 576 amu_$do_translation 000014 constant entry external dcl 76 ref 397 amu_$dp_name_to_segno 000016 constant entry external dcl 77 ref 324 amu_$fdump_mpt_revert_idx 000022 constant entry external dcl 79 ref 400 amu_$fdump_mpt_temp_change_idx 000020 constant entry external dcl 78 ref 394 amu_$hardcore_info_set_cur_ptrs 000024 constant entry external dcl 80 ref 305 amu_$return_val_per_process 000026 constant entry external dcl 81 ref 392 amu_$slt_search_init_seg_ptr 000030 constant entry external dcl 82 ref 308 amu_$slt_search_seg_ptr 000032 constant entry external dcl 83 ref 306 amu_et_$bad_segno 000044 external static fixed bin(35,0) dcl 91 ref 255 256 amu_et_$error_indirect 000046 external static fixed bin(35,0) dcl 92 ref 769 amu_et_$invalid_seq 000050 external static fixed bin(35,0) dcl 93 ref 136 141 319 512 530 564 584 amu_et_$modifier_before_range 000076 external static fixed bin(35,0) dcl 104 ref 666 693 721 733 amu_et_$negative_offset 000052 external static fixed bin(35,0) dcl 94 ref 354 818 amu_et_$no_segname 000054 external static fixed bin(35,0) dcl 95 ref 167 amu_et_$no_va_specified 000056 external static fixed bin(35,0) dcl 96 ref 232 amu_et_$not_its_ptr 000060 external static fixed bin(35,0) dcl 97 ref 853 amu_et_$not_octal_off_mod 000064 external static fixed bin(35,0) dcl 99 ref 470 681 amu_et_$not_octal_offset 000062 external static fixed bin(35,0) dcl 98 ref 558 amu_et_$not_octal_range 000066 external static fixed bin(35,0) dcl 100 ref 763 amu_et_$not_octal_segno 000070 external static fixed bin(35,0) dcl 101 ref 503 513 amu_et_$null_ptr 000072 external static fixed bin(35,0) dcl 102 ref 253 amu_et_$specified_modifier 000074 external static fixed bin(35,0) dcl 103 ref 665 692 718 730 amu_info based structure level 1 dcl 3-3 amu_info_ptr 000250 automatic pointer dcl 3-45 set ref 125* 160* 216* 296 300 305* 308 314 315* 324* 329 329 392* 394* 394 394 397* 400* 526* 576* ap 000112 automatic pointer dcl 59 set ref 220* 226* 227 228 585 arg based char packed unaligned dcl 343 in procedure "finish_va_resolution" ref 347 arg parameter char packed unaligned dcl 619 in procedure "parse_arg" set ref 598 637 641 642 643* 661 663 670* 672 682 686 687* 690 699 716 723 727 728 735 742* 744* 750* 755 762 764 768 770* arg based char packed unaligned dcl 60 in procedure "amu_parse_ptr_args_" set ref 227 228* 585 arg_position parameter fixed bin(17,0) dcl 620 set ref 598 656 675 700 710* 710 753 756 780* 780 argl 000462 automatic fixed bin(21,0) dcl 341 set ref 346* 347 argno 000114 automatic fixed bin(17,0) dcl 61 set ref 179* 184* 225 226* 228* argp 000464 automatic pointer dcl 342 set ref 346* 347 array 1 based structure array level 2 dcl 2-23 ref 394 394 baseno builtin function dcl 108 ref 170 253 519 534 578 840 baseptr builtin function dcl 108 ref 300 325 code 000505 automatic fixed bin(35,0) dcl 423 in procedure "get_va" set ref 440* 465* 466 492* 493* 494 508* 509* 518 525* 526* 527 550* 551 576* 577 code parameter fixed bin(35,0) dcl 381 in procedure "get_indirect_ptr" set ref 367 391* 397* code 000672 automatic fixed bin(35,0) dcl 627 in procedure "parse_arg" set ref 633* 670* 671 687* 688 742* 743 750* 751 code parameter fixed bin(35,0) dcl 265 in procedure "check_name" set ref 262 275* 284* 285 297* 306* 307 308* 312 315* 317 324* 325 code 000115 automatic fixed bin(35,0) dcl 62 in procedure "amu_parse_ptr_args_" set ref 126* 163* 165* 166 167 167* 174 cv_dec_check_ 000036 constant entry external dcl 84 ref 742 cv_oct_check_ 000034 constant entry external dcl 84 ref 284 465 493 550 670 687 750 data_buf_ptr 000706 automatic pointer dcl 807 set ref 830* 832* 839 data_ptr parameter pointer dcl 382 set ref 367 397* doing parameter fixed bin(17,0) dcl 621 in procedure "parse_arg" set ref 598 636 638* 645* 651* 654* 655* 660 676* 680* 701* 709* 715 717* 729* 756* 758* doing 000116 automatic fixed bin(17,0) dcl 63 in procedure "amu_parse_ptr_args_" set ref 224* 225 228* 231 early_dump 2 based bit(1) level 3 packed packed unaligned dcl 3-3 ref 296 308 ecode 12 based fixed bin(35,0) level 2 in structure "va" dcl 419 in procedure "get_va" set ref 470* 503* 512 513* 530* 558* 564* 584* ecode parameter fixed bin(35,0) dcl 248 in procedure "bad_segno" set ref 245 252* 253* 255* 256* 258 ecode 12 based fixed bin(35,0) level 2 in structure "va" dcl 339 in procedure "finish_va_resolution" set ref 345* 354* ecode 12 based fixed bin(35,0) level 2 in structure "va" dcl 803 in procedure "resolve_indirection" set ref 818* 824* 832* 833 843* 853* ecode 12 based fixed bin(35,0) level 2 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 128* 136 136* 141 141* 147 232 232* 233 233* 236 319* 665* 666* 681* 692* 693* 718* 721* 730* 733* 763* 769* error_found 000244 automatic bit(1) packed unaligned dcl 123 in procedure "amu_parse_ptr_args_" set ref 133* 134* 135 139* 140 error_found parameter bit(1) packed unaligned dcl 411 in procedure "get_va" set ref 406 441* 469* 502* 511* 529* 557* 566* 583* error_found 000673 automatic bit(1) packed unaligned dcl 628 in procedure "parse_arg" set ref 634* 643* 644 649* 650 745* 765* 771* error_found parameter bit(1) packed unaligned dcl 798 in procedure "resolve_indirection" set ref 787 812* 817* 825* 834* 844* 851* error_msg 13 based varying char(80) level 2 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 131* 236 320* 663* 682* 690* 723* 735* 744* 764* 770* error_msg parameter varying char dcl 266 in procedure "check_name" set ref 262 276* 286* 291* error_msg 13 based varying char(80) level 2 in structure "va" dcl 419 in procedure "get_va" set ref 471* 504* 509* 510 514* 514 531* 559* 565* 585* error_msg 13 based varying char(80) level 2 in structure "va" dcl 339 in procedure "finish_va_resolution" set ref 347* 355* error_msg 13 based varying char(80) level 2 in structure "va" dcl 803 in procedure "resolve_indirection" set ref 819* 826* 835* 845* 852* error_msg 000117 automatic varying char(256) dcl 64 in procedure "amu_parse_ptr_args_" set ref 164* 165* 166 error_table_$noentry 000100 external static fixed bin(35,0) dcl 105 ref 233 error_table_$seg_not_found 000102 external static fixed bin(35,0) dcl 106 ref 233 297 fdump_info based structure level 1 dcl 2-3 fdump_info_ptr 14 based pointer level 2 dcl 3-3 ref 394 394 fdump_process_table based structure level 1 dcl 2-23 fdump_process_table_ptr 246 based pointer level 2 dcl 2-3 ref 394 394 fixed builtin function dcl 108 ref 170 253 519 534 535 578 579 840 841 flags 2 based structure level 2 dcl 3-3 forsw 000245 automatic bit(1) packed unaligned dcl 214 set ref 222* 227* 740 741* fp_table based structure level 1 unaligned dcl 2-28 hard_ptr_space 000220 automatic structure level 1 unaligned dcl 65 set ref 279 hardcore_cur based structure level 1 unaligned dcl 1-40 hardcore_cur_ptr 000246 automatic pointer dcl 1-38 set ref 279* 305* 306 306 308 308 hardcore_info based structure level 1 dcl 1-6 hardcore_info_ptr 16 based pointer level 2 dcl 3-3 ref 300 i 000440 automatic fixed bin(17,0) dcl 270 set ref 281* 282 284 284 ignore 000674 automatic fixed bin(17,0) dcl 629 in procedure "parse_arg" set ref 744* 770* ignore 000506 automatic fixed bin(17,0) dcl 424 in procedure "get_va" set ref 531* ignore 000441 automatic fixed bin(17,0) dcl 271 in procedure "check_name" set ref 286* 291* 320* ind_pos 000507 automatic fixed bin(17,0) dcl 425 set ref 443* 447 451 458 476 484 index builtin function dcl 108 ref 443 index_changed 000474 automatic bit(1) packed unaligned dcl 388 set ref 390* 393* 399 401* indirect_ptr 000710 automatic pointer dcl 808 set ref 830 840 841 indirect_specified parameter bit(1) packed unaligned dcl 412 set ref 406 441* 447* 458 476 484 indirect_sw 000236 automatic bit(1) packed unaligned dcl 66 set ref 134* 139 indirection_specified 000675 automatic bit(1) packed unaligned dcl 630 set ref 634* 643* 649 ioa_$rsnnl 000040 constant entry external dcl 85 ref 286 291 320 531 744 770 its based structure level 1 dcl 4-5 its_mod 0(30) based bit(6) level 2 packed packed unaligned dcl 4-5 ref 839 lbound builtin function dcl 108 ref 394 394 length builtin function dcl 108 ref 282 442 max_segno constant fixed bin(18,0) initial dcl 249 ref 255 mod_idx 6 based fixed bin(17,0) level 3 dcl 5-39 set ref 675* 700* mod_pos 000543 automatic fixed bin(17,0) dcl 429 set ref 444* 450 451 452 452 453 457 460 modifier_before_indirect 3(22) based bit(1) level 3 in structure "va" packed packed unaligned dcl 339 in procedure "finish_va_resolution" ref 351 modifier_before_indirect 3(22) based bit(1) level 3 in structure "va" packed packed unaligned dcl 419 in procedure "get_va" set ref 454* modifier_before_indirect 3(22) based bit(1) level 3 in structure "va" packed packed unaligned dcl 803 in procedure "resolve_indirection" ref 814 nargs parameter fixed bin(17,0) dcl 622 in procedure "parse_arg" ref 598 756 nargs 000237 automatic fixed bin(17,0) dcl 67 in procedure "amu_parse_ptr_args_" set ref 221* 225 228* null builtin function dcl 108 ref 132 253 277 318 528 number parameter fixed bin(18,0) dcl 384 set ref 367 397* offset 000511 automatic fixed bin(18,0) dcl 426 in procedure "get_va" set ref 550* 552 572 offset 1 based fixed bin(18,0) level 2 in structure "va" packed packed unaligned dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 128* 146 offset 1 based fixed bin(18,0) level 2 in structure "va" packed packed unaligned dcl 419 in procedure "get_va" set ref 490* 535* 552* 552 572* 572 579* offset 000712 automatic fixed bin(18,0) dcl 809 in procedure "resolve_indirection" set ref 813* 815* 816 832* offset 1 based fixed bin(18,0) level 2 in structure "va" packed packed unaligned dcl 339 in procedure "finish_va_resolution" set ref 352* 352 353 offset 000676 automatic fixed bin(18,0) dcl 631 in procedure "parse_arg" set ref 670* 673 687* 697 742* 750* 752 offset 1 based fixed bin(18,0) level 2 in structure "va" packed packed unaligned dcl 803 in procedure "resolve_indirection" set ref 813 815 841* offset_modifier 2 based fixed bin(18,0) level 2 in structure "va" dcl 339 in procedure "finish_va_resolution" ref 352 offset_modifier 2 based fixed bin(18,0) level 2 in structure "va" dcl 419 in procedure "get_va" set ref 465* 468* offset_modifier 2 based fixed bin(18,0) level 2 in structure "va" dcl 803 in procedure "resolve_indirection" ref 815 offset_modifier 2 based fixed bin(18,0) level 2 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 128* 673* 697* offset_modifier 000512 automatic char(32) packed unaligned dcl 427 in procedure "get_va" set ref 452* 457* 465* 471 offset_name 000522 automatic char(65) packed unaligned dcl 428 set ref 481* 550* 556 559 576* offset_pos 000510 automatic fixed bin(17,0) dcl 425 set ref 445* 446 480 481 p_va_args parameter pointer dcl 623 set ref 598 643* 649* pointer_arg parameter char packed unaligned dcl 413 ref 406 442 443 444 445 449 452 453 457 458 460 476 pointer_arg_length 000504 automatic fixed bin(17,0) dcl 414 set ref 442* 452 pointers based structure level 2 dcl 1-6 range 3 based fixed bin(18,0) level 2 packed packed unaligned dcl 5-39 set ref 128* 752* range_idx 7 based fixed bin(17,0) level 3 dcl 5-39 set ref 753* rel builtin function dcl 108 ref 535 579 841 resolved_va 10 based pointer level 2 dcl 5-39 set ref 132* rtrim builtin function dcl 108 ref 282 501 504 514 556 sci_ptr parameter pointer dcl 54 set ref 112 150 177 182 226* 346* search builtin function dcl 108 ref 281 444 445 seg parameter fixed bin(17,0) dcl 383 set ref 367 392* 397* seg_name 000544 automatic char(32) packed unaligned dcl 430 set ref 480* 484* 485* 493* 501 504 509* 514 526* 531* 576* segment_name parameter char packed unaligned dcl 267 ref 262 278 segname 000100 automatic char(32) packed unaligned dcl 47 set ref 161* 162* 165* segname_entry 000110 automatic bit(1) initial packed unaligned dcl 48 set ref 48* segno 000554 automatic fixed bin(17,0) dcl 431 in procedure "get_va" set ref 493* 496 segno parameter fixed bin(18,0) dcl 247 in procedure "bad_segno" ref 245 253 255 256 segno 000453 automatic fixed bin(17,0) dcl 313 in procedure "check_name" set ref 324* 325 segno 16 based structure level 2 in structure "hardcore_info" dcl 1-6 in procedure "amu_parse_ptr_args_" segno 000240 automatic fixed bin(17,0) dcl 68 in procedure "amu_parse_ptr_args_" set ref 170* 173 segno based fixed bin(18,0) level 2 in structure "va" dcl 803 in procedure "resolve_indirection" set ref 824* 832 840* 843* segno based fixed bin(18,0) level 2 in structure "va" dcl 419 in procedure "get_va" set ref 491* 496* 519* 534* 578* segno based fixed bin(18,0) level 2 in structure "va" dcl 339 in procedure "finish_va_resolution" set ref 345* segno based fixed bin(18,0) level 2 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 128* 145 segno_given 000555 automatic bit(1) packed unaligned dcl 432 set ref 441* 495* 563 slt based structure level 3 dcl 1-6 sltntp 2 based pointer level 2 dcl 1-40 set ref 306* 308* sltp based pointer level 2 dcl 1-40 set ref 306* 308* ssu_$arg_ptr 000042 constant entry external dcl 87 ref 226 346 stack_0 22 based fixed bin(15,0) level 3 dcl 1-6 ref 300 stack_idx 000442 automatic fixed bin(17,0) dcl 272 set ref 284* 290 290 296 300 substr builtin function dcl 108 ref 280 280 284 284 286 291 452 453 457 458 460 476 480 481 484 641 661 686 716 727 temp_ptr 000556 automatic pointer dcl 433 in procedure "get_va" set ref 509* 519 526* 528 534 535 576* 578 579 temp_ptr parameter pointer dcl 268 in procedure "check_name" set ref 262 277* 300* 306* 308* 315* 318 325* temp_ptr 000242 automatic pointer dcl 70 in procedure "amu_parse_ptr_args_" set ref 165* 170 temp_ptr_given 000560 automatic bit(1) packed unaligned dcl 434 set ref 441* 537* 571 test_name 000443 automatic char(32) packed unaligned dcl 273 set ref 278* 280 280 281 282 284 284 286 291 306* 308* 315* 320* 324* two_parts 000561 automatic bit(1) packed unaligned dcl 435 set ref 441* 446* 479 542 549 type 3 based fixed bin(17,0) level 2 packed packed unaligned dcl 3-3 ref 314 329 329 va based structure level 1 unaligned dcl 803 in procedure "resolve_indirection" va based structure level 1 unaligned dcl 339 in procedure "finish_va_resolution" va based structure level 1 unaligned dcl 5-39 in procedure "amu_parse_ptr_args_" va based structure level 1 unaligned dcl 419 in procedure "get_va" va_arg 000562 automatic varying char(256) dcl 436 set ref 449* 453* 458* 460* 476* 480 481 484 485 va_arg_ptr parameter pointer dcl 338 in procedure "finish_va_resolution" ref 336 345 345 346 347 351 351 352 352 352 353 354 355 355 va_arg_ptr parameter pointer dcl 415 in procedure "get_va" ref 406 454 465 466 468 470 471 490 491 496 497 503 504 509 510 512 513 514 514 519 520 530 531 534 535 536 552 552 553 558 559 564 565 572 572 573 578 579 580 584 585 va_arg_ptr parameter pointer dcl 799 in procedure "resolve_indirection" ref 787 813 814 815 815 818 819 819 824 824 826 826 832 832 833 835 835 840 841 843 843 845 845 852 852 853 va_args 000252 automatic structure level 1 dcl 5-14 set ref 127 va_args_ptr 000414 automatic pointer dcl 5-40 set ref 127* 128 128 128 128 128 128 130 131 131 132 134* 136 136 139* 141 141 145 146 147 219* 232 232 233 233 236 236 319 320 642 648 654 656 662 663 665 665 666 672 672 673 674 675 681 682 689 690 692 692 693 697 698 699 699 700 718 718 721 723 730 730 733 735 744 752 753 754 755 755 763 764 769 770 770 va_idx 5 based fixed bin(17,0) level 3 in structure "va" dcl 339 in procedure "finish_va_resolution" set ref 346* va_idx 5 based fixed bin(17,0) level 3 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 656* va_position 5 based structure level 2 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 128* va_position 5 based structure level 2 in structure "va" dcl 339 in procedure "finish_va_resolution" va_string 40 based varying char(256) level 2 in structure "va" dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 131* 642* 672* 672 699* 699 755* 755 770* va_string 40 based varying char(256) level 2 in structure "va" dcl 339 in procedure "finish_va_resolution" ref 355 va_string 40 based varying char(256) level 2 in structure "va" dcl 803 in procedure "resolve_indirection" ref 819 826 835 845 852 va_switches 3(19) based structure level 2 in structure "va" packed packed unaligned dcl 419 in procedure "get_va" va_switches 3(19) based structure level 2 in structure "va" packed packed unaligned dcl 339 in procedure "finish_va_resolution" va_switches 3(19) based structure level 2 in structure "va" packed packed unaligned dcl 803 in procedure "resolve_indirection" va_switches 3(19) based structure level 2 in structure "va" packed packed unaligned dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 130* valid_modifier 3(20) based bit(1) level 3 in structure "va" packed packed unaligned dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 654 665 674* 692 698* 718 730 valid_modifier 3(20) based bit(1) level 3 in structure "va" packed packed unaligned dcl 339 in procedure "finish_va_resolution" ref 351 valid_modifier 3(20) based bit(1) level 3 in structure "va" packed packed unaligned dcl 419 in procedure "get_va" set ref 466* valid_range 3(21) based bit(1) level 3 packed packed unaligned dcl 5-39 set ref 662 689 754* valid_va 3(19) based bit(1) level 3 in structure "va" packed packed unaligned dcl 419 in procedure "get_va" set ref 497* 520* 536* 553* 573* 580* valid_va 3(19) based bit(1) level 3 in structure "va" packed packed unaligned dcl 5-39 in procedure "amu_parse_ptr_args_" set ref 648 verify builtin function dcl 108 ref 501 556 728 762 word parameter fixed bin(18,0) dcl 384 set ref 367 397* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AMU_FDUMP_INFO_VERSION internal static char(8) initial packed unaligned dcl 2-43 AMU_FDUMP_INFO_VERSION_1 internal static char(8) initial packed unaligned dcl 2-42 AMU_INFO_VERSION internal static char(8) initial packed unaligned dcl 3-57 AMU_INFO_VERSION_1 internal static char(8) initial packed unaligned dcl 3-56 AMU_INFO_VERSION_2 internal static char(8) initial packed unaligned dcl 3-58 INDIRECT_TYPE internal static fixed bin(17,0) initial dcl 3-47 ITP_MODIFIER internal static bit(6) initial packed unaligned dcl 4-56 NETWORK_FDUMP_TYPE internal static fixed bin(17,0) initial dcl 3-47 NETWORK_ONLINE_TYPE internal static fixed bin(17,0) initial dcl 3-47 ONLINE_PROCESS_TYPE internal static fixed bin(17,0) initial dcl 3-47 ONLINE_TYPE internal static fixed bin(17,0) initial dcl 3-47 PDIR_SUFFIX internal static char(4) initial packed unaligned dcl 3-60 alloc_fdump_process_table_size automatic fixed bin(17,0) dcl 2-40 amu_area based area(1024) dcl 3-43 fp_table_ptr automatic pointer dcl 2-38 itp based structure level 1 dcl 4-18 itp_unsigned based structure level 1 dcl 4-43 its_unsigned based structure level 1 dcl 4-30 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON_ARG 000476 constant label dcl 216 ref 180 185 END_FINISH_VA 001537 constant label dcl 362 ref 348 356 END_GET_VA 003012 constant label dcl 593 ref 472 505 512 515 532 542 560 567 586 END_GET_VA_ARGS 000634 constant label dcl 238 END_RESOLVE 004350 constant label dcl 857 ref 820 827 836 846 854 ERROR_RETURN 000642 constant label dcl 242 ref 234 236 RETURN_PARSE_ARG 004104 constant label dcl 780 ref 639 641 646 652 667 677 683 694 702 705 711 724 737 746 759 775 amu_parse_ptr_args_ 000145 constant entry external dcl 35 amu_parse_ptr_args_$get_segno 000337 constant entry external dcl 150 amu_parse_ptr_args_$get_va_args 000433 constant entry external dcl 177 amu_parse_ptr_args_$get_va_args_given_start 000457 constant entry external dcl 182 amu_parse_ptr_args_$resolve_va 000162 constant entry external dcl 112 bad_segno 000643 constant entry internal dcl 245 ref 345 824 843 check_name 000703 constant entry internal dcl 262 ref 165 509 fill_va 003714 constant label dcl 752 ref 743 finish_va_resolution 001423 constant entry internal dcl 336 ref 238 get_indirect_ptr 001540 constant entry internal dcl 367 ref 832 get_va 001634 constant entry internal dcl 406 ref 134 643 parse_arg 003013 constant entry internal dcl 598 ref 228 resolve_indirection 004107 constant entry internal dcl 787 ref 139 649 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6122 6226 5413 6132 Length 6610 5413 104 345 507 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_parse_ptr_args_ 756 external procedure is an external procedure. bad_segno internal procedure shares stack frame of external procedure amu_parse_ptr_args_. check_name internal procedure shares stack frame of external procedure amu_parse_ptr_args_. finish_va_resolution internal procedure shares stack frame of external procedure amu_parse_ptr_args_. get_indirect_ptr internal procedure shares stack frame of external procedure amu_parse_ptr_args_. get_va internal procedure shares stack frame of external procedure amu_parse_ptr_args_. parse_arg internal procedure shares stack frame of external procedure amu_parse_ptr_args_. resolve_indirection internal procedure shares stack frame of external procedure amu_parse_ptr_args_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME amu_parse_ptr_args_ 000100 segname amu_parse_ptr_args_ 000110 segname_entry amu_parse_ptr_args_ 000111 al amu_parse_ptr_args_ 000112 ap amu_parse_ptr_args_ 000114 argno amu_parse_ptr_args_ 000115 code amu_parse_ptr_args_ 000116 doing amu_parse_ptr_args_ 000117 error_msg amu_parse_ptr_args_ 000220 hard_ptr_space amu_parse_ptr_args_ 000236 indirect_sw amu_parse_ptr_args_ 000237 nargs amu_parse_ptr_args_ 000240 segno amu_parse_ptr_args_ 000242 temp_ptr amu_parse_ptr_args_ 000244 error_found amu_parse_ptr_args_ 000245 forsw amu_parse_ptr_args_ 000246 hardcore_cur_ptr amu_parse_ptr_args_ 000250 amu_info_ptr amu_parse_ptr_args_ 000252 va_args amu_parse_ptr_args_ 000414 va_args_ptr amu_parse_ptr_args_ 000440 i check_name 000441 ignore check_name 000442 stack_idx check_name 000443 test_name check_name 000453 segno check_name 000462 argl finish_va_resolution 000464 argp finish_va_resolution 000474 index_changed get_indirect_ptr 000504 pointer_arg_length get_va 000505 code get_va 000506 ignore get_va 000507 ind_pos get_va 000510 offset_pos get_va 000511 offset get_va 000512 offset_modifier get_va 000522 offset_name get_va 000543 mod_pos get_va 000544 seg_name get_va 000554 segno get_va 000555 segno_given get_va 000556 temp_ptr get_va 000560 temp_ptr_given get_va 000561 two_parts get_va 000562 va_arg get_va 000672 code parse_arg 000673 error_found parse_arg 000674 ignore parse_arg 000675 indirection_specified parse_arg 000676 offset parse_arg 000706 data_buf_ptr resolve_indirection 000710 indirect_ptr resolve_indirection 000712 offset resolve_indirection THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_e_as r_ne_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out return_mac shorten_stack ext_entry ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. amu_$definition_get_prn amu_$definition_ptr amu_$do_translation amu_$dp_name_to_segno amu_$fdump_mpt_revert_idx amu_$fdump_mpt_temp_change_idx amu_$hardcore_info_set_cur_ptrs amu_$return_val_per_process amu_$slt_search_init_seg_ptr amu_$slt_search_seg_ptr cv_dec_check_ cv_oct_check_ ioa_$rsnnl ssu_$arg_ptr THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. amu_et_$bad_segno amu_et_$error_indirect amu_et_$invalid_seq amu_et_$modifier_before_range amu_et_$negative_offset amu_et_$no_segname amu_et_$no_va_specified amu_et_$not_its_ptr amu_et_$not_octal_off_mod amu_et_$not_octal_offset amu_et_$not_octal_range amu_et_$not_octal_segno amu_et_$null_ptr amu_et_$specified_modifier error_table_$noentry error_table_$seg_not_found LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 48 000141 35 000144 112 000153 125 000201 126 000205 127 000206 128 000210 130 000224 131 000237 132 000241 133 000243 134 000244 135 000270 136 000273 137 000301 139 000302 140 000307 141 000312 145 000320 146 000323 147 000327 148 000331 150 000332 160 000356 161 000362 162 000365 163 000372 164 000373 165 000374 166 000377 167 000406 168 000413 170 000414 173 000420 174 000423 175 000425 177 000426 179 000446 180 000450 182 000451 184 000472 185 000475 216 000476 219 000502 220 000505 221 000510 222 000512 224 000513 225 000515 226 000524 227 000542 228 000552 229 000603 231 000604 232 000607 233 000616 234 000623 236 000624 238 000634 242 000642 245 000643 252 000645 253 000646 255 000657 256 000666 258 000673 262 000703 275 000721 276 000723 277 000725 278 000727 279 000734 280 000736 281 000751 282 000763 284 001000 285 001034 286 001040 287 001075 290 001076 291 001102 292 001137 296 001140 297 001146 298 001151 300 001152 301 001157 305 001160 306 001171 307 001222 308 001225 312 001261 314 001264 315 001272 317 001316 318 001321 319 001325 320 001331 321 001360 324 001361 325 001406 328 001415 329 001416 334 001422 336 001423 345 001425 346 001444 347 001465 348 001501 351 001502 352 001513 353 001520 354 001523 355 001526 356 001536 362 001537 367 001540 390 001542 391 001543 392 001544 393 001563 394 001565 397 001577 399 001621 400 001623 401 001632 404 001633 406 001634 440 001645 441 001646 442 001662 443 001663 444 001675 445 001710 446 001722 447 001724 449 001732 450 001742 451 001745 452 001747 453 001757 454 001770 455 001774 457 001775 458 002005 460 002021 465 002031 466 002056 468 002063 469 002064 470 002070 471 002073 472 002100 474 002101 476 002102 479 002115 480 002117 481 002124 482 002132 484 002133 485 002147 490 002153 491 002160 492 002161 493 002162 494 002204 495 002206 496 002210 497 002214 498 002217 501 002220 502 002244 503 002251 504 002256 505 002266 508 002267 509 002270 510 002317 511 002327 512 002333 513 002337 514 002341 515 002407 518 002411 519 002413 520 002417 521 002421 525 002422 526 002423 527 002447 528 002451 529 002455 530 002462 531 002467 532 002516 534 002517 535 002525 536 002532 537 002534 538 002536 542 002537 549 002541 550 002543 551 002565 552 002567 553 002577 554 002601 556 002602 557 002625 558 002632 559 002637 560 002644 563 002645 564 002647 565 002655 566 002662 567 002666 571 002667 572 002671 573 002701 574 002703 576 002704 577 002734 578 002736 579 002744 580 002751 581 002753 583 002754 584 002761 585 002766 586 003010 593 003012 598 003013 633 003024 634 003025 636 003027 637 003033 638 003041 639 003043 641 003044 642 003050 643 003061 644 003105 645 003110 646 003113 648 003114 649 003120 650 003134 651 003137 652 003142 654 003143 655 003153 656 003156 658 003160 660 003161 661 003163 662 003172 663 003176 665 003206 666 003215 667 003220 670 003221 671 003244 672 003246 673 003305 674 003310 675 003312 676 003314 677 003316 680 003317 681 003322 682 003326 683 003337 686 003340 687 003342 688 003365 689 003367 690 003373 692 003405 693 003414 694 003417 697 003420 698 003422 699 003424 700 003462 701 003465 702 003467 705 003470 709 003471 710 003473 711 003475 713 003476 715 003477 716 003501 717 003510 718 003512 721 003522 723 003525 724 003535 727 003536 728 003540 729 003553 730 003555 733 003565 735 003570 737 003600 740 003601 741 003603 742 003604 743 003627 744 003631 745 003664 746 003666 750 003667 751 003712 752 003714 753 003722 754 003725 755 003727 756 003764 758 003773 759 003775 762 003776 763 004013 764 004017 765 004027 766 004031 768 004032 769 004036 770 004042 771 004101 775 004103 780 004104 784 004106 787 004107 812 004111 813 004115 814 004122 815 004126 816 004130 817 004131 818 004134 819 004137 820 004147 824 004150 825 004165 826 004172 827 004204 830 004205 832 004207 833 004234 834 004241 835 004245 836 004255 839 004256 840 004262 841 004266 843 004272 844 004307 845 004314 846 004326 848 004327 851 004330 852 004334 853 004344 854 004347 857 004350 ----------------------------------------------------------- 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