COMPILATION LISTING OF SEGMENT probe_listen_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/27/88 1239.6 mst Thu 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-07-02,LJAdams), approve(86-07-23,MCR7464), 18* audit(86-07-23,GDixon), install(86-07-24,MR12.0-1103): 19* probe_info.input_switch was not maintaining the correct value through 20* different invocations of probe; e.g., after a break point had been 21* executed. Problem fixed. 22* 2) change(88-09-07,WAAnderson), approve(88-09-30,MCR7952), 23* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 24* Added format control comment to make the source more readable. 25* END HISTORY COMMENTS */ 26 27 probe_listen_: 28 procedure (P_probe_info_ptr, P_code); 29 30 /* * Listener procedure for the "probe" debugger 31* * Created out of subsystem_listen_, 0/22/79 W. Olin Sibert 32* Modified JRD 16 Oct 79 33* Modified 09/21/80 WOS, to fix so errors in breakpoints will call listener (bug 188) 34* 35* entries here: 36* 37* listen - basic read/eval loop 38* interpret_line and check_line - take line as parameter 39* 40* These entries have to be careful of each other, because you can be called with the 41* same probe_info in effect. For example, while at probe top level (listen_) you can call 42* "if", which used interpret_line, or try to set a break, which uses check_line. 43* You can also be using interpret_line to execute a break list, see a "halt", which 44* will call listen. In this, rarer, case, i think it is sufficient to save/restore 45* probe_info.ct 46**/ 47 /* Made to skip leading whitespace and not prompt after blank line 09/10/81 S. Herbst */ 48 /* Made prompt mode static 04/26/82 S. Herbst */ 49 /* Made cleanup handler reset probe_static_info.last_break_segno (recursive breaks in probe) 08/15/83 S. Herbst */ 50 51 dcl ( 52 P_probe_info_ptr pointer, /* -> probe info (Input) */ 53 P_request_line_ptr pointer, 54 P_request_line_lth fixed bin (21), 55 P_code fixed binary (35) 56 ) parameter; 57 58 dcl WHITE char (4) int static options (constant) 59 init /* SP HT FF NL */ (" 60 "); 61 62 dcl execute_bit bit (1) aligned; 63 /* new value of probe_info.flags.execute */ 64 65 dcl 1 saved_info automatic aligned, 66 /* various information to be saved/restored */ 67 2 input_type fixed bin, 68 2 work_area_ptr pointer unaligned, 69 2 expression_area_ptr pointer unaligned, 70 2 request_name character (32) varying, 71 2 abort_probe_label label variable, 72 2 abort_line_label label variable, 73 2 token_info like probe_info.token_info, 74 2 flags aligned like probe_info.flags, 75 2 ct ptr unal; 76 77 dcl code fixed binary (35); 78 79 dcl (input_ptr, original_input_ptr) 80 pointer; /* pointer to current location in input string */ 81 dcl (input_lth, input_used_lth) 82 fixed bin (21); 83 dcl input_string char (input_lth) based (input_ptr); 84 85 dcl input_buffer_ptr pointer; 86 dcl input_buffer_lth fixed bin (21); 87 dcl input_buffer char (input_buffer_lth) 88 based (input_buffer_ptr); 89 dcl start fixed bin (21); 90 91 dcl local_work_area area (1536) automatic; 92 /* area for tokens, etc. */ 93 94 dcl add_char_offset_ entry (ptr, fixed bin (21)) returns (ptr); 95 dcl com_err_ entry () options (variable); 96 dcl cu_$cp entry (pointer, fixed binary (21), 97 fixed binary (35)); 98 dcl cu_$grow_stack_frame entry (fixed bin (18), ptr, fixed bin (35)); 99 dcl continue_to_signal_ entry (fixed bin (35)); 100 dcl ioa_$ioa_switch entry options (variable); 101 dcl ioa_$ioa_switch_nnl entry options (variable); 102 dcl iox_$control entry (pointer, char (*), pointer, 103 fixed bin (35)); 104 dcl iox_$get_line entry (pointer, pointer, fixed binary (21), 105 fixed binary (21), fixed binary (35)); 106 107 dcl probe_announce_entry_ entry (ptr); 108 dcl probe_listen_ entry (ptr, fixed bin (35)); 109 dcl probe_scan_input_ entry (pointer, pointer, fixed bin (21), 110 pointer, 111 fixed bin, fixed bin (21), pointer, 112 fixed bin (35)); 113 dcl probe_error_ entry options (variable); 114 dcl probe_fault_handler_ entry (ptr); 115 116 dcl ( 117 iox_$user_input, 118 iox_$error_output 119 ) pointer external static; 120 121 dcl ( 122 error_table_$unimplemented_version, 123 error_table_$long_record, 124 error_table_$end_of_info, 125 error_table_$short_record 126 ) fixed bin (35) external static; 127 128 dcl ( 129 probe_et_$syntax_error, 130 probe_et_$complex_expr, 131 probe_et_$convert_err, 132 probe_et_$error_in_break, 133 probe_et_$program_interrupt 134 ) fixed binary (35) external static; 135 136 dcl (cleanup, program_interrupt, area, conversion, any_other) 137 condition; 138 139 dcl (addr, empty, length, max, null, ptr, size, substr, verify) 140 builtin; 141 /* */ 142 143 listen: 144 entry (P_probe_info_ptr, P_code); 145 146 probe_info_ptr = P_probe_info_ptr; 147 148 if probe_info.probe_info_version ^= probe_info_version_1 then do; 149 P_code = error_table_$unimplemented_version; 150 return; 151 end; 152 153 saved_info.ct = probe_info.ct; 154 155 probe_info.abort_probe_label = LISTEN_RETURN; 156 probe_info.abort_line_label = READ; 157 158 on program_interrupt 159 begin; /* set up our various condition handlers */ 160 call process_interruption (); 161 goto probe_info.abort_line_label; /* do a non-local GOTO out of here */ 162 end; 163 164 on cleanup 165 call clean_up_listener (); 166 167 on area 168 begin; /* catch problems with our areas */ 169 if probe_modes.ignore_faults 170 then 171 call continue_to_signal_ ((0)); 172 else call probe_error_ (probe_info_ptr, probe_et_$complex_expr); 173 end; 174 175 on conversion 176 begin; /* catch conversion errors */ 177 if probe_modes.ignore_faults 178 then 179 call continue_to_signal_ ((0)); 180 else call probe_error_ (probe_info_ptr, probe_et_$convert_err); 181 end; 182 183 on any_other 184 begin; /* this will handle any other problems */ 185 if probe_modes.ignore_faults 186 then 187 call continue_to_signal_ ((0)); 188 else call probe_fault_handler_ (probe_info_ptr); 189 end; 190 191 probe_info.in_listener = "1"b; /* running the listener */ 192 193 /* LISTENER LOOP */ 194 195 call initialize_console_reading (); 196 197 probe_info.work_area_ptr = addr (local_work_area); 198 199 probe_info.input_type = CONSOLE_INPUT; 200 code = 0; /* no errors encountered */ 201 202 do while ("1"b); /* exit is via call to abort_probe */ 203 READ: 204 205 probe_info.flags.executing_request = "0"b; 206 /* not executing now */ 207 input_lth = 0; /* reset the input buffer */ 208 209 call read_from_console (); 210 call process_input_line (); 211 end; /* of listener loop */ 212 213 LISTEN_RETURN: 214 call clean_up_listener (); 215 216 P_code = code; /* code will be set if an error or interruption occurred */ 217 218 return; 219 220 221 clean_up_listener: 222 proc; 223 224 probe_info.static_info_ptr -> probe_static_info.last_break_segno = "0"b; 225 probe_info.ct = saved_info.ct; 226 227 end clean_up_listener; 228 /* */ 229 230 interpret_line: 231 entry (P_probe_info_ptr, P_request_line_ptr, P_request_line_lth, P_code); 232 233 /* * These two entries are used to process individual request lines. 234* * The interpret_line entry executes the request line, and the check_line 235* * entry just checks it for syntax. Both entries save the old state of the 236* * listener, and restore it upon return or cleanup. 237* 238* * called from break_handler, or to check syntax 239**/ 240 241 execute_bit = "1"b; 242 goto INTERPRET_LINE_COMMON; 243 244 245 check_line: 246 entry (P_probe_info_ptr, P_request_line_ptr, P_request_line_lth, P_code); 247 248 execute_bit = "0"b; 249 goto INTERPRET_LINE_COMMON; 250 251 252 INTERPRET_LINE_COMMON: 253 probe_info_ptr = P_probe_info_ptr; 254 255 if probe_info.probe_info_version ^= probe_info_version_1 then do; 256 P_code = error_table_$unimplemented_version; 257 return; 258 end; 259 260 if ^probe_info.in_listener & ^probe_info.in_interpret_line then do; 261 /* only if lowest level */ 262 probe_info.abort_probe_label = INTERPRET_LINE_RETURN; 263 probe_info.abort_line_label = INTERPRET_LINE_RETURN; 264 265 on program_interrupt 266 begin; /* if no listener, punt on program_interrupt */ 267 code = probe_et_$program_interrupt; 268 /* indicate why we returned */ 269 goto probe_info.abort_line_label; 270 end; 271 272 on area 273 begin; /* set up other handlers as well, if no listener */ 274 if probe_modes.ignore_faults 275 then 276 call continue_to_signal_ ((0)); 277 else call probe_error_ (probe_info_ptr, probe_et_$complex_expr); 278 end; 279 280 on conversion 281 begin; /* catch conversion errors */ 282 if probe_modes.ignore_faults 283 then 284 call continue_to_signal_ ((0)); 285 else call probe_error_ (probe_info_ptr, probe_et_$convert_err); 286 end; 287 288 on any_other 289 begin; /* this will handle any other problems */ 290 if probe_modes.ignore_faults 291 then 292 call continue_to_signal_ ((0)); 293 else call probe_fault_handler_ (probe_info_ptr); 294 end; 295 296 probe_info.in_interpret_line = "1"b; 297 /* indicate whats happening */ 298 end; /* of setting up handlers when there is no listener already */ 299 300 call save_probe_info (); /* save the relevant parts */ 301 302 on cleanup /* this will restore the things copied above */ 303 call clean_up_interpret_line (); 304 305 probe_info.flags.execute = execute_bit; 306 probe_info.flags.executing_request = "0"b; 307 probe_info.work_area_ptr = addr (local_work_area); 308 309 input_ptr = P_request_line_ptr; 310 input_lth = P_request_line_lth; 311 code = 0; /* no errors encountered yet */ 312 313 call process_input_line (); 314 315 call clean_up_interpret_line (); /* All done */ 316 P_code = 0; 317 return; /* successful return */ 318 319 INTERPRET_LINE_RETURN: 320 321 call process_interruption (); 322 323 call clean_up_interpret_line (); 324 325 P_code = code; /* code will be set if an error or interruption occurred */ 326 return; /* end of code for $interpret_line entry */ 327 328 329 clean_up_interpret_line: 330 proc (); 331 332 /* * This is the cleanup handler for probe_listen_$interpret_line */ 333 334 335 probe_info.input_type = saved_info.input_type; 336 probe_info.work_area_ptr = saved_info.work_area_ptr; 337 probe_info.expression_area_ptr = saved_info.expression_area_ptr; 338 probe_info.request_name = saved_info.request_name; 339 probe_info.abort_probe_label = saved_info.abort_probe_label; 340 probe_info.abort_line_label = saved_info.abort_line_label; 341 probe_info.token_info = saved_info.token_info; 342 probe_info.flags = saved_info.flags; 343 return; 344 end; 345 346 save_probe_info: 347 proc (); 348 349 /* * This procedure saves the relevant parts of probe_info, which are restored by the code above */ 350 351 saved_info.input_type = probe_info.input_type; 352 saved_info.work_area_ptr = probe_info.work_area_ptr; 353 saved_info.expression_area_ptr = probe_info.expression_area_ptr; 354 saved_info.request_name = probe_info.request_name; 355 saved_info.abort_probe_label = probe_info.abort_probe_label; 356 saved_info.abort_line_label = probe_info.abort_line_label; 357 saved_info.token_info = probe_info.token_info; 358 saved_info.flags = probe_info.flags; 359 return; 360 end; /* internal procedure save_probe_info */ 361 362 /* */ 363 364 process_interruption: 365 proc (); 366 367 /* This procedure exists to flush command streams, and put the user in a consistent 368* state after an error or quit. */ 369 370 if probe_info.input_type = CONSOLE_INPUT then do; 371 /* then input is from console */ 372 input_lth = 0; /* flush read ahead */ 373 call iox_$control (probe_info.input_switch, "resetread", (null ()), (0)) 374 ; 375 code = probe_et_$program_interrupt; 376 end; 377 378 else do; /* input was from a break */ 379 380 /* the old probe only gave this message in "long" mode - in m y opinion 381* it is too important to ever ignore */ 382 383 call ioa_$ioa_switch (iox_$error_output, 384 "Break aborted. Type ""continue"" to restart program."); 385 386 /* Strategy will be to flush commands left in break command list and "stop" 387* Simulate a stop, then return */ 388 389 call probe_announce_entry_ (probe_info_ptr); 390 391 call probe_listen_ (probe_info_ptr, (0)); 392 393 code = probe_et_$error_in_break; 394 end; 395 396 end; /* process_interruption internal procedure */ 397 398 /* */ 399 400 process_input_line: 401 proc (); 402 403 /* This internal procedure processes the current input buffer 404* 405* GLOBAL INPUT/OUTPUT: input_ptr, input_lth, input_used_lth 406* i smell a kludge. 407* 408* Note that language can change while executing a request. probe_scan_input stops at the end 409* of a statement, so we resume scan, under possibly new conditions 410**/ 411 412 dcl first_token pointer; /* first token of current command */ 413 dcl next_token pointer; /* to next command to be parsed */ 414 dcl exhausted bit (1) aligned; 415 /* have we reached the end of an input string */ 416 417 probe_info.end_token = SEMI_COLON; 418 419 exhausted = "0"b; /* to begin with, input string is full */ 420 421 do while (^exhausted); /* execute until we run out of string */ 422 work_area = empty (); /* initialize token storage */ 423 424 call probe_scan_input_ (probe_info_ptr, input_ptr, input_lth, 425 addr (work_area), 426 probe_info.language_type, input_used_lth, first_token, code); 427 428 if code ^= 0 429 then /* error detected scanning input */ 430 call probe_error_ (probe_info_ptr, code); 431 432 /* interpret the tokenized input */ 433 434 do probe_info.ct = first_token repeat next_token 435 while (probe_info.ct ^= null); 436 /* loop through all the tokens */ 437 if probe_info.ct -> token.type = NAME_TYPE then do; 438 /* should be a keyword */ 439 440 dcl request_entry_variable entry variable options (variable); 441 442 dcl old_expression_area_ptr pointer; 443 444 /* * This is the area used for keeping reference_nodes, among other things. It should 445* * probably be an extensible area, so it would be smaller and take up less stack frame, 446* * but I'm not sure whether that works yet. -- wos, 07/16/79 */ 447 448 dcl local_expression_area area (4100) automatic; 449 450 dcl probe_request_mgr_$find_request 451 entry (ptr, char (*), entry, pointer, 452 fixed bin (35)); 453 454 455 old_expression_area_ptr = probe_info.expression_area_ptr; 456 /* set up to save/restore */ 457 458 on cleanup 459 begin; 460 probe_info.expression_area_ptr = old_expression_area_ptr; 461 end; 462 463 local_expression_area = empty (); 464 465 probe_info.expression_area_ptr = addr (local_expression_area); 466 467 call probe_request_mgr_$find_request (probe_info_ptr, 468 current_identifier_name, 469 request_entry_variable, probe_request_info_ptr, code); 470 471 if code ^= 0 472 then call probe_error_ (probe_info_ptr, code); 473 474 probe_request_table_ptr = ptr (probe_request_info_ptr, 0); 475 /* find out its primary name */ 476 request_namelist_ptr = ptr (probe_request_table_ptr, 477 probe_request_info.namelist_loc); 478 479 probe_info.ct = probe_info.ct -> token.next; 480 probe_info.request_name = request_namelist.names (1); 481 probe_info.executing_request = "1"b; 482 /* at last */ 483 484 call request_entry_variable (probe_info_ptr); 485 486 probe_info.executing_request = "0"b; 487 /* if it bothers to return */ 488 489 490 end; 491 492 else if probe_info.ct -> operator.type = PERIOD then do; 493 /* tell user who we are */ 494 probe_info.ct = probe_info.ct -> token.next; 495 /* keep syntax okay */ 496 if probe_info.ct -> token.type = PERIOD 497 /* has a .. in bad place */ 498 then call ioa_$ioa_switch (iox_$error_output, 499 "The .. escape convention can be used only at the beginning of a line" 500 ); 501 if probe_info.ct -> token.type < probe_info.end_token 502 then 503 call probe_error_ (probe_info_ptr, probe_et_$syntax_error); 504 if probe_info.execute 505 then 506 call ioa_$ioa_switch (probe_info.output_switch, 507 probe_static_info.version_string); 508 end; 509 510 else if probe_info.ct -> token.type >= probe_info.end_token 511 then ; /* do nothing, skip this one */ 512 513 else call probe_error_ (probe_info_ptr, probe_et_$syntax_error); 514 /* constant doesn't belong here */ 515 next_token = probe_info.ct -> token.next; 516 end; /* of loop through tokens */ 517 518 input_ptr = addr (substr (input_ptr -> input_string, input_used_lth + 1)); 519 input_lth = max (0, input_lth - input_used_lth); 520 if input_lth = 0 521 then exhausted = "1"b; 522 else exhausted = "0"b; 523 end; /* of loop through commands in a line */ 524 return; 525 end; /* process_input_line internal procedure */ 526 527 /* */ 528 529 read_from_console: 530 proc (); 531 532 /* * This procedure reads input from the current input switch. Since it grows probe's 533* * stack frame so it can hold the input buffer, it must be quick. It does not 534* * assume that it is the only procedure extending the stack, and therefore does 535* * not assume that grow_stack_frame will allocate contiguous blocks. 536* 537* * GLOBAL import: original_input_ptr, maybe others? is this a kludge Olin? 538**/ 539 540 dcl initial_input_buffer char (256) aligned based; 541 /* the first console buffer, grown with our first call */ 542 543 dcl read_ptr pointer; 544 dcl (total_input_lth, original_input_lth, this_input_lth) 545 fixed bin (21); 546 547 dcl (old_buffer_ptr, new_buffer_ptr) 548 pointer; 549 dcl (old_buffer_lth, new_buffer_lth) 550 fixed bin (21); 551 dcl old_buffer char (old_buffer_lth) based (old_buffer_ptr); 552 dcl new_buffer char (new_buffer_lth) based (new_buffer_ptr); 553 554 total_input_lth = input_lth; /* it started out empty */ 555 original_input_lth = input_lth; /* so we can revert from a ".." */ 556 read_ptr = addr (substr (input_buffer, (total_input_lth + 1), 1)); 557 /* start reading right after last input */ 558 559 print_prompt_and_read: 560 if probe_static_info.prompt_on_sw /* print the prompt */ 561 then call ioa_$ioa_switch_nnl (probe_info.output_switch, 562 probe_static_info.prompt, 563 probe_info.depth > 1, probe_info.depth); 564 565 console_read_loop: 566 call iox_$get_line (probe_info.input_switch, read_ptr, 567 (input_buffer_lth - total_input_lth), this_input_lth, code); 568 569 if code = 0 then do; /* read successfully */ 570 input_lth = this_input_lth + total_input_lth; 571 end; /* of case for code = 0 */ 572 573 else if code = error_table_$long_record then do; 574 /* must grow stack frame for the rest of this */ 575 old_buffer_ptr = input_buffer_ptr; 576 old_buffer_lth = input_buffer_lth; 577 new_buffer_lth = old_buffer_lth * 2; 578 /* twice as much room */ 579 580 call cu_$grow_stack_frame (size (new_buffer), new_buffer_ptr, code); 581 if code ^= 0 582 then goto probe_info.abort_line_label; 583 584 new_buffer = old_buffer; 585 read_ptr = addr (substr (new_buffer, old_buffer_lth + 1, 1)); 586 /* where to start reading more input */ 587 total_input_lth = total_input_lth + this_input_lth; 588 589 input_buffer_ptr = new_buffer_ptr; 590 input_buffer_lth = new_buffer_lth;/* copy into the global values */ 591 goto console_read_loop; /* and try reading some more */ 592 end; /* of case for error_table_$long_record */ 593 594 else if code = error_table_$end_of_info then do; 595 call com_err_ (0, probe_static_info.name, 596 "End of information reached reading switch ""^a"". Reverting to user_input.", 597 probe_info.input_switch -> iocb.name); 598 probe_info.input_switch = iox_$user_input; 599 /* revert to user_input */ 600 input_lth = this_input_lth + total_input_lth; 601 end; /* of case for error_table_$end_of_info */ 602 603 else if code = error_table_$short_record then do; 604 /* pretty unlikely.... */ 605 if this_input_lth = 0 then do; 606 call com_err_ (0, probe_static_info.name, 607 "End of information reached reading switch ""^a"". Reverting to user_input.", 608 probe_info.input_switch -> iocb.name); 609 probe_info.input_switch = iox_$user_input; 610 /* revert to user_input */ 611 end; 612 input_lth = this_input_lth + total_input_lth; 613 end; 614 615 else do; /* something pretty bonkers.... */ 616 call com_err_ (code, probe_static_info.name, 617 "Reading switch ^a. Reverting to user_input.", 618 probe_info.input_switch -> iocb.name); 619 call probe_error_ (probe_info_ptr, code); 620 input_lth = 0; /* Sorry, nothing there */ 621 end; 622 623 if input_lth = 1 624 then go to console_read_loop; /* no prompt after blank line */ 625 626 start = verify (input_buffer, WHITE); 627 if start = 0 628 then go to console_read_loop; /* line consisting entirely of white space */ 629 if start > 1 then do; /* skip leading whitespace */ 630 input_buffer_ptr = add_char_offset_ (input_buffer_ptr, start - 1); 631 input_buffer_lth = input_buffer_lth - start + 1; 632 input_lth = input_lth - start + 1; 633 end; 634 if input_lth > 2 then do; /* check for ".." escape convention */ 635 if substr (input_buffer, 1, 2) = ".." then do; 636 call cu_$cp (addr (substr (input_buffer, 3, 1)), (input_lth - 2), 637 (0)); 638 639 input_lth = original_input_lth; 640 /* revert to original buffer contents, and get more input */ 641 read_ptr = addr (substr (input_buffer, (input_lth + 1), 1)); 642 total_input_lth = input_lth; 643 goto print_prompt_and_read; 644 end; 645 end; /* of checking for ".." escape */ 646 647 input_ptr, original_input_ptr = input_buffer_ptr; 648 return; /* end of code for read_from_console entrypoint */ 649 650 651 initialize_console_reading: 652 entry (); /* entry to initialize stuff */ 653 654 probe_info.input_switch = probe_static_info.input_switch; 655 656 call cu_$grow_stack_frame (size (initial_input_buffer), input_buffer_ptr, 657 code); 658 /* try to grab first buffer */ 659 if code ^= 0 660 then goto probe_info.abort_line_label; 661 662 input_buffer_lth = length (input_buffer_ptr -> initial_input_buffer); 663 input_lth = 0; /* nothing in it, right now */ 664 665 input_ptr, original_input_ptr = input_buffer_ptr; 666 return; /* end of code for initialization entry point */ 667 end; /* read_from_console internal procedure */ 668 669 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 */ 670 671 2 1 /* BEGIN INCLUDE FILE probe_static_info.incl.pl1 */ 2 2 2 3 /* * This include file describes per-process information about probe, such 2 4* * as various options available and the info directories and modes. 2 5* * 2 6* * Created: 06/06/79 W. Olin Sibert */ 2 7 2 8 dcl 1 probe_static_info aligned based (probe_info.static_info_ptr), /* per-process data about probe */ 2 9 2 probe_info_version fixed bin, /* same as probe_info.probe_info_version */ 2 10 2 11 2 version aligned, 2 12 3 major_version fixed bin, 2 13 3 minor_version fixed bin, 2 14 3 version_string char (32) unaligned, /* like "4.3f, patch 1" */ 2 15 2 16 2 name char (32) unaligned, /* "probe" */ 2 17 2 prompt character (40) varying, /* prompt for reading requests */ 2 18 2 switches, 2 19 3 brief_sw bit (1) unaligned, /* briefer break messages, no header (default OFF) */ 2 20 3 no_handle_faults_sw bit (1) unaligned, /* don't handle bad ptr faults (default OFF) */ 2 21 3 recursive_breaks_sw bit (1) unaligned, /* don't ignore recursive breaks in probe */ 2 22 3 prompt_on_sw bit (1) unaligned, /* prompt for request lines */ 2 23 3 switch_pad bit (32) unaligned, 2 24 2 25 2 scratch_segment_ptr pointer, /* pointer to probe_scratch_ -- always valid */ 2 26 2 break_segment_ptr pointer, /* pointer to Person.breaks -- valid only if needed */ 2 27 2 28 2 seg_info_offset_ptr pointer, /* pointer to seg_info_offset array */ 2 29 2 30 2 probe_segno bit (18), /* segment number of probe itself */ 2 31 2 last_break_segno bit (18), /* segment number of last interrupted program */ 2 32 2 33 2 stack_info aligned, /* information about the stack trace in probe_scratch_ */ 2 34 3 level_chain pointer unaligned, /* first level frame entry pointer */ 2 35 3 max_level fixed bin, /* number of stack levels */ 2 36 3 flags aligned, 2 37 (4 good_stack, 2 38 4 traced_with_all, /* whether the stack trace includes support frames */ 2 39 4 pad1 (34)) bit (1) unaligned, 2 40 2 41 2 modes_ptr pointer unaligned, /* pointer to modes -- same as probe_info.modes_ptr */ 2 42 2 43 2 request_table_info aligned, /* info for request definitions */ 2 44 3 array_ptr pointer, /* pointer to array of request table pointers */ 2 45 3 array_size fixed bin, /* number of elements in use */ 2 46 3 array_max_size fixed bin, /* max number of elements in array */ 2 47 3 using_internal_array bit (1) aligned, /* whether or not we are using the array in probe_static_info */ 2 48 2 49 2 io_switches, /* switches probe does its I/O on */ 2 50 3 input_switch pointer, 2 51 3 output_switch pointer, 2 52 3 (private_input_sw, private_output_sw) bit (1) aligned, 2 53 /* created by ids, ods and should be destroyed */ 2 54 2 55 2 info_directory_info aligned, /* info about info directories */ 2 56 3 array_ptr pointer, 2 57 3 array_size fixed bin, 2 58 3 array_max_size fixed bin, 2 59 3 using_internal_array bit (1) aligned, 2 60 2 61 2 exclude_name_info aligned, /* info for exclude array used in printing values */ 2 62 3 array_ptr pointer, 2 63 3 array_size fixed bin, 2 64 3 array_max_size fixed bin, 2 65 3 using_internal_array bit (1) aligned, 2 66 2 67 2 null_seg_info_ptr pointer unaligned, /* pointer to the "null" seg_info block */ 2 68 2 69 2 initial_arrays, /* initial versions of various arrays */ 2 70 3 request_table_ptr_array (10) pointer aligned, 2 71 3 info_directory_name_array (3) char (168) unaligned, 2 72 3 exclude_name_array (6) char (32) unaligned, 2 73 2 74 2 metering_info, /* last values for "mode meter" */ 2 75 3 last_clock fixed bin (71), 2 76 3 last_vclock fixed bin (71), 2 77 3 last_page_faults fixed bin, 2 78 2 79 2 end_of_probe_static_info fixed bin; 2 80 2 81 2 82 dcl 1 probe_seg_info_array aligned based (probe_static_info.seg_info_offset_ptr), 2 83 2 count fixed bin, /* number of entries in seg_info_offset array */ 2 84 2 seg_info_offset (0 : seg_info_offset_count refer (probe_seg_info_array.count)) bit (18) aligned; 2 85 2 86 dcl seg_info_offset_count fixed bin; /* one less than the number of info_offsets */ 2 87 2 88 dcl probe_request_tables (probe_static_info.request_table_info.array_max_size) /* array of request table pointers */ 2 89 pointer aligned based (probe_static_info.request_table_info.array_ptr); 2 90 2 91 dcl probe_info_directories (probe_static_info.info_directory_info.array_max_size) /* array of info directories */ 2 92 char (168) unaligned based (probe_static_info.info_directory_info.array_ptr); 2 93 2 94 dcl probe_exclude_names (probe_static_info.exclude_name_info.array_max_size) /* array of exclude names */ 2 95 char (168) unaligned based (probe_static_info.exclude_name_info.array_ptr); 2 96 2 97 /* END INCLUDE FILE probe_static_info.incl.pl1 */ 672 673 3 1 /* BEGIN INCLUDE FILE probe_info_constants.incl.pl1 */ 3 2 /* Created: 06/25/79 W. Olin Sibert */ 3 3 3 4 dcl (RETURN_TO_CALLER init (1), /* return methods */ 3 5 RETURN_TO_FRAME init (2), 3 6 RETURN_TO_CONDITION init (3), 3 7 RETURN_TO_BREAK init (4)) fixed bin internal static options (constant); 3 8 3 9 dcl (ENTRY_AT_CALL init (1), /* entered by a call to probe */ 3 10 ENTRY_AT_BREAK init (2), /* entered by a call to probe$break */ 3 11 ENTRY_AT_HALT init (3)) fixed bin internal static options (constant); /* entered by a call to probe$halt */ 3 12 3 13 dcl (CONSOLE_INPUT init (1), 3 14 BREAK_INPUT init (2), 3 15 MACRO_INPUT init (3)) fixed bin internal static options (constant); 3 16 3 17 /* END INCLUDE FILE probe_info_constants.incl.pl1 */ 674 675 4 1 /* BEGIN INCLUDE FILE ... probe_modes.incl.pl1 4 2* 4 3* this structure is part of the per-user data base, which alledgedly is 4 4* kept in person_id.probe no probe code other than probe_modes_mgr_ 4 5* should set these modes, or refer to them BY NAME in communication 4 6* with the user I do not even promise a one-to-one correspondance 4 7* between the modes the user can set and the names here 4 8* 4 9* James R. Davis 12 July 79 */ 4 10 /* Added meter 09/23/82 S. Herbst */ 4 11 /* Added truncate_strings 05/21/84 S. Herbst */ 4 12 4 13 4 14 dcl 1 probe_modes aligned based (probe_info.modes_ptr), 4 15 2 len_modes, 4 16 3 error_messages fixed bin, /* for use by probe_error_ */ 4 17 3 qualification fixed bin, /* for use by probe_print_value_ */ 4 18 3 value_print fixed bin, /* for probe_print_value_ */ 4 19 3 pad (5) fixed bin, /* for use by probe_mxyzptlk */ 4 20 2 value_separator char (32) varying, 4 21 2 bits, 4 22 3 use_exclude_names bit (1) unal, 4 23 3 debug_modes_set bit (1) unaligned, /* whether any of the *MAGIC* modes are set */ 4 24 3 ignore_faults bit (1) unaligned, 4 25 3 octal_bitstrings bit (1) unal, /* for Olin Sibert */ 4 26 3 catch_errors bit (1) unaligned, /* calls to probe_error_ will call cu_$cl */ 4 27 3 catch_error_once bit (1) unaligned, /* next call to probe_error_ will call cu_$cl */ 4 28 3 debug_breaks bit (1) unaligned, /* causes various things to happen at breakpoints */ 4 29 3 use_prompt bit (1) unaligned, /* whether to use the prompt */ 4 30 3 debug bit (1) unaligned, /* controls printing of random debugging information */ 4 31 3 meter bit (1) unaligned, /* controls printing of time, vcpu, pf's at halt */ 4 32 3 truncate_strings bit (1) unaligned, /* controls value req printing only 1st 200 chars/bits */ 4 33 3 pad bit (25) unaligned; 4 34 4 35 dcl (BRIEF_mode_type init (1), 4 36 SHORT_mode_type init (2), 4 37 LONG_mode_type init (3)) fixed bin internal static options (constant); 4 38 4 39 /* END INCLUDE FILE ... probe_modes.incl.pl1 */ 4 40 676 677 5 1 /* BEGIN INCLUDE FILE probe_tokens.incl.pl1 */ 5 2 /* Split up into probe_tokens and probe_references, 04/22/79 WOS */ 5 3 5 4 dcl 1 token_header aligned based, /* header information common to all tokens */ 5 5 2 next pointer unaligned, /* pointer to next token in chain */ 5 6 2 prev pointer unaligned, /* same for previous token */ 5 7 2 type bit (18) aligned, 5 8 2 buffer_ptr pointer unaligned, /* pointer to beginning of input buffer */ 5 9 2 location fixed bin (17) unal, /* offset in input buffer */ 5 10 2 length fixed bin (17) unal, 5 11 2 flags aligned, 5 12 (3 leading_whitespace, /* there is whitespace before thios token */ 5 13 3 trailing_whitespace) bit (1) unaligned, /* and same for after */ 5 14 3 pad1 bit (34) unaligned; 5 15 5 16 dcl 1 token aligned based, /* produced by scan_probe_input_ */ 5 17 2 header aligned like token_header; /* that's all there is */ 5 18 5 19 dcl 1 identifier aligned based, /* keyword or identifier token */ 5 20 2 header aligned like token_header, 5 21 2 length fixed bin, /* length of name */ 5 22 2 name pointer unaligned; /* to string in buffer containing name */ 5 23 5 24 dcl 1 operator aligned based, /* for punctuation */ 5 25 2 header aligned like token_header; /* nothing but a header here */ 5 26 5 27 dcl 1 constant aligned based, /* for strings pointers numbers etc */ 5 28 2 header aligned like token_header, 5 29 2 encoded_precision aligned, /* encoded precision kludge for assign_ */ 5 30 3 scale fixed bin (17) unaligned, /* arithmetic scale */ 5 31 3 precision fixed bin (17) unaligned, /* arithmetic precision or other size */ 5 32 2 scale_and_precision fixed bin (35), /* An identical copy of the two values above */ 5 33 2 data_type fixed bin, /* standard data type code + packed bit */ 5 34 2 data_ptr pointer unaligned; 5 35 5 36 5 37 dcl (OPERATOR_TYPE init ("100"b), /* types for above */ 5 38 NAME_TYPE init ("010"b), 5 39 CONSTANT_TYPE init ("001"b)) bit (18) internal static options (constant); 5 40 5 41 5 42 dcl current_identifier_name /* Overlays for looking at the current tokens */ 5 43 char (probe_info.ct -> identifier.length) based (probe_info.ct -> identifier.name); 5 44 dcl 1 current_constant aligned like constant based (probe_info.ct); 5 45 dcl 1 current_token aligned like token based (probe_info.ct); 5 46 5 47 /* END INCLUDE FILE probe_tokens.incl.pl1 */ 678 679 6 1 /* BEGIN INCLUDE FILE ... probe_operators.incl.pl1 */ 6 2 6 3 6 4 6 5 /****^ HISTORY COMMENTS: 6 6* 1) change(88-09-20,WAAnderson), approve(88-09-20,MCR7952), 6 7* audit(88-09-30,JRGray), install(88-10-24,MR12.2-1184): 6 8* Added new C operators. 6 9* END HISTORY COMMENTS */ 6 10 6 11 6 12 /* These are the operator.types for each defined operator */ 6 13 /* Modified June 83 JMAthane for PASCAL_ARROW new operator */ 6 14 /* Added PASCAL_RANGE and PASCAL_ASSIGN 07/26/83 S. Herbst */ 6 15 /* Modified April 88 Hinatsu Addition of C types */ 6 16 6 17 dcl (PLUS init ("400001"b3), MINUS init ("400002"b3), 6 18 TIMES init ("400003"b3), SLASH init ("400004"b3), 6 19 OR_BAR init ("400005"b3), NOT_SIGN init ("400006"b3), 6 20 LESS_THAN init ("400007"b3), GREATER_THAN init ("400010"b3), 6 21 EQUALS init ("400011"b3), NOT_EQUALS init ("400012"b3), 6 22 NOT_GREATER_THAN init ("400013"b3), NOT_LESS_THAN init ("400014"b3), 6 23 PERIOD init ("400015"b3), COLON init ("400016"b3), 6 24 AMPERSAND init ("400017"b3), PERCENT init ("400020"b3), 6 25 DOLLAR_SIGN init ("400021"b3), LEFT_BRACKET init ("400022"b3), 6 26 RIGHT_BRACKET init ("400023"b3), ARROW init ("400024"b3), 6 27 COMMA init ("400025"b3), QUESTION_MARK init ("400026"b3), 6 28 PASCAL_ARROW init ("400027"b3), PASCAL_RANGE init ("400030"b3), 6 29 PASCAL_ASSIGN init ("400031"b3), 6 30 6 31 /* Additons to support C types */ 6 32 C_LEFT_SHIFT init ("400032"b3), C_RIGHT_SHIFT init ("400033"b3), 6 33 6 34 /* operator 28 are left for future expansion */ 6 35 6 36 LEFT_PAREN init ("400035"b3), RIGHT_PAREN init ("400036"b3), 6 37 C_EQUAL init ("400037"b3), C_NOT_EQUAL init ("400040"b3), 6 38 SEMI_COLON init ("400041"b3), NEW_LINE init ("400042"b3), 6 39 C_INDIRECTION init ("400034"b3) 6 40 6 41 ) bit (18) aligned internal static options (constant); 6 42 6 43 dcl OPERATOR_VALUES (0:34) char (4) varying internal static options (constant) init 6 44 ("????", "+", "-", "*", "/", "|", "^", "<", 6 45 ">", "=", "^=", "<=", ">=", ".", ":", "&", 6 46 "%", "$", "[", "]", "->", ",", "?", "^", 6 47 "..", ":=", "<<", ">>", "*", "(", ")", 6 48 "==", "!=", ";"," 6 49 "); 6 50 6 51 /* END INCLUDE FILE ... probe_operators.incl.pl1 */ 680 681 7 1 /* BEGIN INCLUDE FILE probe_request_table.incl.pl1 */ 7 2 /* Created (from subsystem_request_table) 04/08/79 W. Olin Sibert */ 7 3 7 4 /* Structures defining the request table used by probe */ 7 5 7 6 dcl 1 probe_request_table aligned based (probe_request_table_ptr), 7 7 2 version fixed binary, 7 8 2 name character (32), /* name of this table */ 7 9 2 flags, /* none yet, just room for expansion */ 7 10 3 pad1 (6) bit (36) unaligned, 7 11 2 n_requests fixed binary, 7 12 2 requests (0 refer (probe_request_table.n_requests)) like probe_request_info aligned; 7 13 7 14 7 15 dcl 1 probe_request_info aligned based (probe_request_info_ptr), /* info about one request */ 7 16 2 code_loc bit (18) unaligned, /* -> (RTBOS) code sequence to invoke request */ 7 17 2 namelist_loc bit (18) unaligned, /* -> (RTBOS) list of names for this request */ 7 18 2 info_string, 7 19 3 loc bit (18) unaligned, /* -> (RTBOS) short description of request */ 7 20 3 lth fixed binary (17) unaligned, /* length of description (0 if none) */ 7 21 2 usage_string, /* Longer message, giving request usage info */ 7 22 3 loc bit (18) unaligned, 7 23 3 lth bit (18) unaligned, 7 24 2 flags, 7 25 (3 unimplemented, /* ON => request is ot yet implemented */ 7 26 3 secret, /* ON => request is not listed by "?" */ 7 27 3 pad2, 7 28 3 is_request, /* ON => this entry is a probe request */ 7 29 3 is_builtin, /* ON => this entry is a probe builtin */ 7 30 3 pad (31)) bit (1) unaligned; 7 31 7 32 7 33 dcl probe_request_table_ptr pointer; 7 34 dcl probe_request_info_ptr pointer; 7 35 7 36 dcl probe_request_table_version fixed bin internal static options (constant) init (1); 7 37 7 38 dcl probe_request_table_version_1 fixed bin internal static options (constant) init (1); 7 39 7 40 7 41 dcl 1 request_namelist aligned based (request_namelist_ptr), 7 42 2 n_names fixed binary, 7 43 2 names (0 refer (request_namelist.n_names)) character (32); 7 44 7 45 dcl request_namelist_ptr pointer; 7 46 7 47 7 48 dcl request_info_string char (request_info_string_lth) aligned based (request_info_string_ptr); 7 49 dcl request_info_string_ptr pointer; 7 50 dcl request_info_string_lth fixed bin (21); 7 51 7 52 7 53 dcl request_usage_string char (request_usage_string_lth) aligned based (request_usage_string_ptr); 7 54 dcl request_usage_string_ptr pointer; 7 55 dcl request_usage_string_lth fixed bin (21); 7 56 7 57 /* END INCLUDE FILE probe_request_table.incl.pl1 */ 682 683 8 1 /* BEGIN INCLUDE FILE ..... iocb.incl.pl1 ..... 13 Feb 1975, M. Asherman */ 8 2 /* Modified 11/29/82 by S. Krupp to add new entries and to change 8 3* version number to IOX2. */ 8 4 /* format: style2 */ 8 5 8 6 dcl 1 iocb aligned based, /* I/O control block. */ 8 7 2 version character (4) aligned, /* IOX2 */ 8 8 2 name char (32), /* I/O name of this block. */ 8 9 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 8 10 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 8 11 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 8 12 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 8 13 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 8 14 2 reserved bit (72), /* Reserved for future use. */ 8 15 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 8 16 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 8 17 /* open(p,mode,not_used,s) */ 8 18 2 close entry (ptr, fixed (35)),/* close(p,s) */ 8 19 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 8 20 /* get_line(p,bufptr,buflen,actlen,s) */ 8 21 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 8 22 /* get_chars(p,bufptr,buflen,actlen,s) */ 8 23 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 8 24 /* put_chars(p,bufptr,buflen,s) */ 8 25 2 modes entry (ptr, char (*), char (*), fixed (35)), 8 26 /* modes(p,newmode,oldmode,s) */ 8 27 2 position entry (ptr, fixed, fixed (21), fixed (35)), 8 28 /* position(p,u1,u2,s) */ 8 29 2 control entry (ptr, char (*), ptr, fixed (35)), 8 30 /* control(p,order,infptr,s) */ 8 31 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 8 32 /* read_record(p,bufptr,buflen,actlen,s) */ 8 33 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 8 34 /* write_record(p,bufptr,buflen,s) */ 8 35 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 8 36 /* rewrite_record(p,bufptr,buflen,s) */ 8 37 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 8 38 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 8 39 /* seek_key(p,key,len,s) */ 8 40 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 8 41 /* read_key(p,key,len,s) */ 8 42 2 read_length entry (ptr, fixed (21), fixed (35)), 8 43 /* read_length(p,len,s) */ 8 44 2 open_file entry (ptr, fixed bin, char (*), bit (1) aligned, fixed bin (35)), 8 45 /* open_file(p,mode,desc,not_used,s) */ 8 46 2 close_file entry (ptr, char (*), fixed bin (35)), 8 47 /* close_file(p,desc,s) */ 8 48 2 detach entry (ptr, char (*), fixed bin (35)); 8 49 /* detach(p,desc,s) */ 8 50 8 51 declare iox_$iocb_version_sentinel 8 52 character (4) aligned external static; 8 53 8 54 /* END INCLUDE FILE ..... iocb.incl.pl1 ..... */ 684 685 686 end probe_listen_; /* external procedure */ SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/27/88 1224.4 probe_listen_.pl1 >spec>install>MR12.2-1194>probe_listen_.pl1 670 1 10/27/88 1223.7 probe_info.incl.pl1 >spec>install>MR12.2-1194>probe_info.incl.pl1 672 2 11/12/82 1624.3 probe_static_info.incl.pl1 >ldd>include>probe_static_info.incl.pl1 674 3 11/26/79 1320.9 probe_info_constants.incl.pl1 >ldd>include>probe_info_constants.incl.pl1 676 4 12/04/84 2012.2 probe_modes.incl.pl1 >ldd>include>probe_modes.incl.pl1 678 5 11/26/79 1320.6 probe_tokens.incl.pl1 >ldd>include>probe_tokens.incl.pl1 680 6 10/26/88 1255.5 probe_operators.incl.pl1 >ldd>include>probe_operators.incl.pl1 682 7 11/26/79 1320.7 probe_request_table.incl.pl1 >ldd>include>probe_request_table.incl.pl1 684 8 05/20/83 1846.4 iocb.incl.pl1 >ldd>include>iocb.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. CONSOLE_INPUT constant fixed bin(17,0) initial dcl 3-13 ref 199 370 NAME_TYPE constant bit(18) initial packed unaligned dcl 5-37 ref 437 PERIOD constant bit(18) initial dcl 6-17 ref 492 496 P_code parameter fixed bin(35,0) dcl 51 set ref 27 143 149* 216* 230 245 256* 316* 325* P_probe_info_ptr parameter pointer dcl 51 ref 27 143 146 230 245 252 P_request_line_lth parameter fixed bin(21,0) dcl 51 ref 230 245 310 P_request_line_ptr parameter pointer dcl 51 ref 230 245 309 SEMI_COLON constant bit(18) initial dcl 6-17 ref 417 WHITE 000000 constant char(4) initial packed unaligned dcl 58 ref 626 abort_line_label 20 000102 automatic label variable level 2 in structure "saved_info" dcl 65 in procedure "probe_listen_" set ref 340 356* abort_line_label 226 based label variable level 3 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 156* 161 263* 269 340* 356 581 659 abort_probe_label 14 000102 automatic label variable level 2 in structure "saved_info" dcl 65 in procedure "probe_listen_" set ref 339 355* abort_probe_label 222 based label variable level 3 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 155* 262* 339* 355 add_char_offset_ 000010 constant entry external dcl 94 ref 630 addr builtin function dcl 139 ref 197 307 424 424 465 518 556 585 636 636 641 any_other 003200 stack reference condition dcl 136 ref 183 288 area 003164 stack reference condition dcl 136 ref 167 272 bits 21 based structure level 2 dcl 4-14 cleanup 003150 stack reference condition dcl 136 ref 164 302 458 code 000135 automatic fixed bin(35,0) dcl 77 set ref 200* 216 267* 311* 325 375* 393* 424* 428 428* 467* 471 471* 565* 569 573 580* 581 594 603 616* 619* 656* 659 com_err_ 000012 constant entry external dcl 95 ref 595 606 616 constant based structure level 1 dcl 5-27 continue_to_signal_ 000020 constant entry external dcl 99 ref 169 177 185 274 282 290 conversion 003172 stack reference condition dcl 136 ref 175 280 ct 13 based pointer level 3 in structure "probe_info" packed packed unaligned dcl 1-18 in procedure "probe_listen_" set ref 153 225* 434* 434* 437 467 467 467 479* 479 492 494* 494 496 501 510 515* ct 32 000102 automatic pointer level 2 in structure "saved_info" packed packed unaligned dcl 65 in procedure "probe_listen_" set ref 153* 225 cu_$cp 000014 constant entry external dcl 96 ref 636 cu_$grow_stack_frame 000016 constant entry external dcl 98 ref 580 656 current_identifier_name based char packed unaligned dcl 5-42 set ref 467* depth 232 based fixed bin(17,0) level 3 dcl 1-18 set ref 559 559* empty builtin function dcl 139 ref 91 422 448 463 end_token 14 based bit(18) level 3 dcl 1-18 set ref 417* 501 510 error_table_$end_of_info 000054 external static fixed bin(35,0) dcl 121 ref 594 error_table_$long_record 000052 external static fixed bin(35,0) dcl 121 ref 573 error_table_$short_record 000056 external static fixed bin(35,0) dcl 121 ref 603 error_table_$unimplemented_version 000050 external static fixed bin(35,0) dcl 121 ref 149 256 execute 64 based bit(1) level 3 packed packed unaligned dcl 1-18 set ref 305* 504 execute_bit 000100 automatic bit(1) dcl 62 set ref 241* 248* 305 executing_request 64(02) based bit(1) level 3 packed packed unaligned dcl 1-18 set ref 203* 306* 481* 486* exhausted 000104 automatic bit(1) dcl 414 set ref 419* 421 520* 522* expression_area_ptr 63 based pointer level 3 in structure "probe_info" packed packed unaligned dcl 1-18 in procedure "probe_listen_" set ref 337* 353 455 460* 465* expression_area_ptr 2 000102 automatic pointer level 2 in structure "saved_info" packed packed unaligned dcl 65 in procedure "probe_listen_" set ref 337 353* first_token 000100 automatic pointer dcl 412 set ref 424* 434 flags 31 000102 automatic structure level 2 in structure "saved_info" dcl 65 in procedure "probe_listen_" set ref 342 358* flags 64 based structure level 2 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 342* 358 header based structure level 2 in structure "operator" dcl 5-24 in procedure "probe_listen_" header based structure level 2 in structure "token" dcl 5-16 in procedure "probe_listen_" identifier based structure level 1 dcl 5-19 ignore_faults 21(02) based bit(1) level 3 packed packed unaligned dcl 4-14 ref 169 177 185 274 282 290 in_interpret_line 64(03) based bit(1) level 3 packed packed unaligned dcl 1-18 set ref 260 296* in_listener 64(01) based bit(1) level 3 packed packed unaligned dcl 1-18 set ref 191* 260 initial_input_buffer based char(256) dcl 540 ref 656 656 662 input_buffer based char packed unaligned dcl 87 set ref 556 626 635 636 636 641 input_buffer_lth 000146 automatic fixed bin(21,0) dcl 86 set ref 556 565 576 590* 626 631* 631 635 636 636 641 662* input_buffer_ptr 000144 automatic pointer dcl 85 set ref 556 575 589* 626 630* 630* 635 636 636 641 647 656* 662 665 input_lth 000142 automatic fixed bin(21,0) dcl 81 set ref 207* 310* 372* 424* 518 519* 519 520 554 555 570* 600* 612* 620* 623 632* 632 634 636 639* 641 642 663* input_ptr 000136 automatic pointer dcl 79 set ref 309* 424* 518* 518 647* 665* input_string based char packed unaligned dcl 83 set ref 518 input_switch 62 based pointer level 3 in structure "probe_static_info" dcl 2-8 in procedure "probe_listen_" ref 654 input_switch 66 based pointer level 3 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 373* 565* 595 598* 606 609* 616 654* input_type 20 based fixed bin(17,0) level 3 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 199* 335* 351 370 input_type 000102 automatic fixed bin(17,0) level 2 in structure "saved_info" dcl 65 in procedure "probe_listen_" set ref 335 351* input_used_lth 000143 automatic fixed bin(21,0) dcl 81 set ref 424* 518 519 io_switches 66 based structure level 2 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" io_switches 62 based structure level 2 in structure "probe_static_info" dcl 2-8 in procedure "probe_listen_" ioa_$ioa_switch 000022 constant entry external dcl 100 ref 383 496 504 ioa_$ioa_switch_nnl 000024 constant entry external dcl 101 ref 559 iocb based structure level 1 dcl 8-6 iox_$control 000026 constant entry external dcl 102 ref 373 iox_$error_output 000046 external static pointer dcl 116 set ref 383* 496* iox_$get_line 000030 constant entry external dcl 104 ref 565 iox_$user_input 000044 external static pointer dcl 116 ref 598 609 language_type 21 based fixed bin(17,0) level 3 dcl 1-18 set ref 424* last_break_segno 47 based bit(18) level 2 dcl 2-8 set ref 224* length builtin function dcl 139 in procedure "probe_listen_" ref 662 length 6 based fixed bin(17,0) level 2 in structure "identifier" dcl 5-19 in procedure "probe_listen_" ref 467 467 listener_info 210 based structure level 2 dcl 1-18 local_expression_area 000114 automatic area(4100) dcl 448 set ref 448* 463* 465 local_work_area 000150 automatic area(1536) dcl 91 set ref 91* 197 307 max builtin function dcl 139 ref 519 modes_ptr 2 based pointer level 2 packed packed unaligned dcl 1-18 ref 169 177 185 274 282 290 name 13 based char(32) level 2 in structure "probe_static_info" packed packed unaligned dcl 2-8 in procedure "probe_listen_" set ref 595* 606* 616* name 7 based pointer level 2 in structure "identifier" packed packed unaligned dcl 5-19 in procedure "probe_listen_" ref 467 name 1 based char(32) level 2 in structure "iocb" dcl 8-6 in procedure "probe_listen_" set ref 595* 606* 616* namelist_loc 0(18) based bit(18) level 2 packed packed unaligned dcl 7-15 ref 476 names 1 based char(32) array level 2 dcl 7-41 ref 480 new_buffer based char packed unaligned dcl 552 set ref 580 580 584* 585 new_buffer_lth 003247 automatic fixed bin(21,0) dcl 549 set ref 577* 580 580 580 580 584 585 590 new_buffer_ptr 003244 automatic pointer dcl 547 set ref 580 580 580* 584 585 589 next based pointer level 3 packed packed unaligned dcl 5-16 ref 479 494 515 next_token 000102 automatic pointer dcl 413 set ref 515* 516 null builtin function dcl 139 ref 373 434 old_buffer based char packed unaligned dcl 551 ref 584 old_buffer_lth 003246 automatic fixed bin(21,0) dcl 549 set ref 576* 577 584 585 old_buffer_ptr 003242 automatic pointer dcl 547 set ref 575* 584 old_expression_area_ptr 000112 automatic pointer dcl 442 set ref 455* 460 operator based structure level 1 dcl 5-24 original_input_lth 003237 automatic fixed bin(21,0) dcl 544 set ref 555* 639 original_input_ptr 000140 automatic pointer dcl 79 set ref 647* 665* output_switch 70 based pointer level 3 dcl 1-18 set ref 504* 559* probe_announce_entry_ 000032 constant entry external dcl 107 ref 389 probe_area_info 56 based structure level 2 dcl 1-18 probe_error_ 000040 constant entry external dcl 113 ref 172 180 277 285 428 471 501 513 619 probe_et_$complex_expr 000062 external static fixed bin(35,0) dcl 128 set ref 172* 277* probe_et_$convert_err 000064 external static fixed bin(35,0) dcl 128 set ref 180* 285* probe_et_$error_in_break 000066 external static fixed bin(35,0) dcl 128 ref 393 probe_et_$program_interrupt 000070 external static fixed bin(35,0) dcl 128 ref 267 375 probe_et_$syntax_error 000060 external static fixed bin(35,0) dcl 128 set ref 501* 513* probe_fault_handler_ 000042 constant entry external dcl 114 ref 188 293 probe_info based structure level 1 dcl 1-18 probe_info_ptr 003206 automatic pointer dcl 1-86 set ref 146* 148 153 155 156 161 169 172* 177 180* 185 188* 191 197 199 203 224 225 252* 255 260 260 262 263 269 274 277* 282 285* 290 293* 296 305 306 307 335 336 337 338 339 340 341 342 351 352 353 354 355 356 357 358 370 373 389* 391* 417 422 424* 424 424 424 428* 434 434 437 455 460 465 467* 467 467 467 471* 479 479 480 481 484* 486 492 494 494 496 501 501 501* 504 504 504 510 510 513* 515 559 559 559 559 559 565 581 595 595 598 606 606 609 616 616 619* 654 654 659 probe_info_version based fixed bin(17,0) level 2 dcl 1-18 ref 148 255 probe_info_version_1 constant fixed bin(17,0) initial dcl 1-90 ref 148 255 probe_listen_ 000034 constant entry external dcl 108 ref 391 probe_modes based structure level 1 dcl 4-14 probe_request_info based structure level 1 dcl 7-15 probe_request_info_ptr 003212 automatic pointer dcl 7-34 set ref 467* 474 476 probe_request_mgr_$find_request 000072 constant entry external dcl 450 ref 467 probe_request_table_ptr 003210 automatic pointer dcl 7-33 set ref 474* 476 probe_scan_input_ 000036 constant entry external dcl 109 ref 424 probe_static_info based structure level 1 dcl 2-8 program_interrupt 003156 stack reference condition dcl 136 ref 158 265 prompt 23 based varying char(40) level 2 dcl 2-8 set ref 559* prompt_on_sw 36(03) based bit(1) level 3 packed packed unaligned dcl 2-8 ref 559 ptr builtin function dcl 139 ref 474 476 random_info 17 based structure level 2 dcl 1-18 read_ptr 003234 automatic pointer dcl 543 set ref 556* 565* 585* 641* request_entry_variable 000106 automatic entry variable dcl 440 set ref 467* 484 request_name 210 based varying char(32) level 3 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 338* 354 480* request_name 3 000102 automatic varying char(32) level 2 in structure "saved_info" dcl 65 in procedure "probe_listen_" set ref 338 354* request_namelist based structure level 1 dcl 7-41 request_namelist_ptr 003214 automatic pointer dcl 7-45 set ref 476* 480 saved_info 000102 automatic structure level 1 dcl 65 size builtin function dcl 139 ref 580 580 656 656 start 000147 automatic fixed bin(21,0) dcl 89 set ref 626* 627 629 630 631 632 static_info_ptr 1 based pointer level 2 packed packed unaligned dcl 1-18 ref 224 504 559 559 595 606 616 654 substr builtin function dcl 139 ref 518 556 585 635 636 636 641 switches 36 based structure level 2 dcl 2-8 this_input_lth 003240 automatic fixed bin(21,0) dcl 544 set ref 565* 570 587 600 605 612 token based structure level 1 dcl 5-16 token_header based structure level 1 dcl 5-4 token_info 24 000102 automatic structure level 2 in structure "saved_info" dcl 65 in procedure "probe_listen_" set ref 341 357* token_info 12 based structure level 2 in structure "probe_info" dcl 1-18 in procedure "probe_listen_" set ref 341* 357 total_input_lth 003236 automatic fixed bin(21,0) dcl 544 set ref 554* 556 565 570 587* 587 600 612 642* type 2 based bit(18) level 3 in structure "token" dcl 5-16 in procedure "probe_listen_" ref 437 496 501 510 type 2 based bit(18) level 3 in structure "operator" dcl 5-24 in procedure "probe_listen_" ref 492 verify builtin function dcl 139 ref 626 version 1 based structure level 2 dcl 2-8 version_string 3 based char(32) level 3 packed packed unaligned dcl 2-8 set ref 504* work_area based area(1024) dcl 1-94 set ref 422* 424 424 work_area_ptr 1 000102 automatic pointer level 2 in structure "saved_info" packed packed unaligned dcl 65 in procedure "probe_listen_" set ref 336 352* work_area_ptr 62 based pointer level 3 in structure "probe_info" packed packed unaligned dcl 1-18 in procedure "probe_listen_" set ref 197* 307* 336* 352 422 424 424 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AMPERSAND internal static bit(18) initial dcl 6-17 ARROW internal static bit(18) initial dcl 6-17 BREAK_INPUT internal static fixed bin(17,0) initial dcl 3-13 BRIEF_mode_type internal static fixed bin(17,0) initial dcl 4-35 COLON internal static bit(18) initial dcl 6-17 COMMA internal static bit(18) initial dcl 6-17 CONSTANT_TYPE internal static bit(18) initial packed unaligned dcl 5-37 C_EQUAL internal static bit(18) initial dcl 6-17 C_INDIRECTION internal static bit(18) initial dcl 6-17 C_LEFT_SHIFT internal static bit(18) initial dcl 6-17 C_NOT_EQUAL internal static bit(18) initial dcl 6-17 C_RIGHT_SHIFT internal static bit(18) initial dcl 6-17 DOLLAR_SIGN internal static bit(18) initial dcl 6-17 ENTRY_AT_BREAK internal static fixed bin(17,0) initial dcl 3-9 ENTRY_AT_CALL internal static fixed bin(17,0) initial dcl 3-9 ENTRY_AT_HALT internal static fixed bin(17,0) initial dcl 3-9 EQUALS internal static bit(18) initial dcl 6-17 GREATER_THAN internal static bit(18) initial dcl 6-17 LEFT_BRACKET internal static bit(18) initial dcl 6-17 LEFT_PAREN internal static bit(18) initial dcl 6-17 LESS_THAN internal static bit(18) initial dcl 6-17 LONG_mode_type internal static fixed bin(17,0) initial dcl 4-35 MACRO_INPUT internal static fixed bin(17,0) initial dcl 3-13 MINUS internal static bit(18) initial dcl 6-17 NEW_LINE internal static bit(18) initial dcl 6-17 NOT_EQUALS internal static bit(18) initial dcl 6-17 NOT_GREATER_THAN internal static bit(18) initial dcl 6-17 NOT_LESS_THAN internal static bit(18) initial dcl 6-17 NOT_SIGN internal static bit(18) initial dcl 6-17 OPERATOR_TYPE internal static bit(18) initial packed unaligned dcl 5-37 OPERATOR_VALUES internal static varying char(4) initial array dcl 6-43 OR_BAR internal static bit(18) initial dcl 6-17 PASCAL_ARROW internal static bit(18) initial dcl 6-17 PASCAL_ASSIGN internal static bit(18) initial dcl 6-17 PASCAL_RANGE internal static bit(18) initial dcl 6-17 PERCENT internal static bit(18) initial dcl 6-17 PLUS internal static bit(18) initial dcl 6-17 QUESTION_MARK internal static bit(18) initial dcl 6-17 RETURN_TO_BREAK internal static fixed bin(17,0) initial dcl 3-4 RETURN_TO_CALLER internal static fixed bin(17,0) initial dcl 3-4 RETURN_TO_CONDITION internal static fixed bin(17,0) initial dcl 3-4 RETURN_TO_FRAME internal static fixed bin(17,0) initial dcl 3-4 RIGHT_BRACKET internal static bit(18) initial dcl 6-17 RIGHT_PAREN internal static bit(18) initial dcl 6-17 SHORT_mode_type internal static fixed bin(17,0) initial dcl 4-35 SLASH internal static bit(18) initial dcl 6-17 TIMES internal static bit(18) initial dcl 6-17 current_constant based structure level 1 dcl 5-44 current_token based structure level 1 dcl 5-45 expression_area based area(1024) dcl 1-95 iox_$iocb_version_sentinel external static char(4) dcl 8-51 probe_area based area(1024) dcl 1-93 probe_exclude_names based char(168) array packed unaligned dcl 2-94 probe_info_directories based char(168) array packed unaligned dcl 2-91 probe_info_version internal static fixed bin(17,0) initial dcl 1-88 probe_request_table based structure level 1 dcl 7-6 probe_request_table_version internal static fixed bin(17,0) initial dcl 7-36 probe_request_table_version_1 internal static fixed bin(17,0) initial dcl 7-38 probe_request_tables based pointer array dcl 2-88 probe_seg_info_array based structure level 1 dcl 2-82 request_info_string based char dcl 7-48 request_info_string_lth automatic fixed bin(21,0) dcl 7-50 request_info_string_ptr automatic pointer dcl 7-49 request_usage_string based char dcl 7-53 request_usage_string_lth automatic fixed bin(21,0) dcl 7-55 request_usage_string_ptr automatic pointer dcl 7-54 scratch_area based area(1024) dcl 1-92 seg_info_offset_count automatic fixed bin(17,0) dcl 2-86 NAMES DECLARED BY EXPLICIT CONTEXT. INTERPRET_LINE_COMMON 000544 constant label dcl 252 ref 242 249 INTERPRET_LINE_RETURN 001055 constant label dcl 319 ref 262 263 LISTEN_RETURN 000477 constant label dcl 213 ref 155 READ 000465 constant label dcl 203 set ref 156 check_line 000531 constant entry external dcl 245 clean_up_interpret_line 001107 constant entry internal dcl 329 ref 302 315 323 clean_up_listener 001071 constant entry internal dcl 221 ref 164 213 console_read_loop 002047 constant label dcl 565 ref 591 623 627 initialize_console_reading 002460 constant entry internal dcl 651 ref 195 interpret_line 000513 constant entry external dcl 230 listen 000165 constant entry external dcl 143 print_prompt_and_read 002010 constant label dcl 559 ref 643 probe_listen_ 000151 constant entry external dcl 27 process_input_line 001333 constant entry internal dcl 400 ref 210 313 process_interruption 001211 constant entry internal dcl 364 ref 160 319 read_from_console 002001 constant entry internal dcl 529 ref 209 save_probe_info 001152 constant entry internal dcl 346 ref 300 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3444 3540 2722 3454 Length 4204 2722 74 430 521 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME probe_listen_ 1750 external procedure is an external procedure. on unit on line 158 64 on unit on unit on line 164 64 on unit on unit on line 167 80 on unit on unit on line 175 80 on unit on unit on line 183 70 on unit clean_up_listener 64 internal procedure is called by several nonquick procedures. on unit on line 265 64 on unit on unit on line 272 80 on unit on unit on line 280 80 on unit on unit on line 288 70 on unit on unit on line 302 64 on unit clean_up_interpret_line 64 internal procedure is called by several nonquick procedures. save_probe_info internal procedure shares stack frame of external procedure probe_listen_. process_interruption 98 internal procedure is called by several nonquick procedures. process_input_line 4230 internal procedure enables or reverts conditions. on unit on line 458 64 on unit read_from_console internal procedure shares stack frame of external procedure probe_listen_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME probe_listen_ 000100 execute_bit probe_listen_ 000102 saved_info probe_listen_ 000135 code probe_listen_ 000136 input_ptr probe_listen_ 000140 original_input_ptr probe_listen_ 000142 input_lth probe_listen_ 000143 input_used_lth probe_listen_ 000144 input_buffer_ptr probe_listen_ 000146 input_buffer_lth probe_listen_ 000147 start probe_listen_ 000150 local_work_area probe_listen_ 003206 probe_info_ptr probe_listen_ 003210 probe_request_table_ptr probe_listen_ 003212 probe_request_info_ptr probe_listen_ 003214 request_namelist_ptr probe_listen_ 003234 read_ptr read_from_console 003236 total_input_lth read_from_console 003237 original_input_lth read_from_console 003240 this_input_lth read_from_console 003242 old_buffer_ptr read_from_console 003244 new_buffer_ptr read_from_console 003246 old_buffer_lth read_from_console 003247 new_buffer_lth read_from_console process_input_line 000100 first_token process_input_line 000102 next_token process_input_line 000104 exhausted process_input_line 000106 request_entry_variable process_input_line 000112 old_expression_area_ptr process_input_line 000114 local_expression_area process_input_line THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a call_ent_var_desc call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_2 enable_op ext_entry int_entry op_empty_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. add_char_offset_ com_err_ continue_to_signal_ cu_$cp cu_$grow_stack_frame ioa_$ioa_switch ioa_$ioa_switch_nnl iox_$control iox_$get_line probe_announce_entry_ probe_error_ probe_fault_handler_ probe_listen_ probe_request_mgr_$find_request probe_scan_input_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$end_of_info error_table_$long_record error_table_$short_record error_table_$unimplemented_version iox_$error_output iox_$user_input probe_et_$complex_expr probe_et_$convert_err probe_et_$error_in_break probe_et_$program_interrupt probe_et_$syntax_error LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 91 000140 27 000145 143 000162 146 000176 148 000202 149 000205 150 000210 153 000211 155 000213 156 000216 158 000221 160 000235 161 000242 164 000246 167 000270 169 000304 172 000322 173 000337 175 000340 177 000354 180 000372 181 000407 183 000410 185 000424 188 000442 189 000451 191 000452 195 000455 197 000456 199 000461 200 000463 202 000464 203 000465 207 000470 209 000471 210 000472 211 000476 213 000477 216 000503 218 000505 230 000506 241 000524 242 000526 245 000527 248 000542 249 000543 252 000544 255 000550 256 000553 257 000556 260 000557 262 000562 263 000565 265 000570 267 000604 269 000607 272 000612 274 000626 277 000644 278 000661 280 000662 282 000676 285 000714 286 000731 288 000732 290 000746 293 000764 294 000773 296 000774 300 000777 302 001000 305 001022 306 001027 307 001031 309 001033 310 001037 311 001041 313 001042 315 001047 316 001053 317 001054 319 001055 323 001061 325 001065 326 001067 221 001070 224 001076 225 001102 227 001105 329 001106 335 001114 336 001120 337 001122 338 001124 339 001131 340 001135 341 001141 342 001147 343 001151 346 001152 351 001153 352 001156 353 001160 354 001162 355 001167 356 001173 357 001177 358 001205 359 001207 364 001210 370 001216 372 001223 373 001224 375 001256 376 001262 383 001263 389 001302 391 001312 393 001325 396 001331 400 001332 448 001340 417 001343 419 001347 421 001350 422 001352 424 001361 428 001412 434 001432 437 001445 455 001452 458 001454 460 001470 461 001476 463 001477 465 001502 467 001506 471 001544 474 001564 476 001567 479 001574 480 001601 481 001606 484 001610 486 001620 490 001624 492 001625 494 001630 496 001632 501 001656 504 001702 508 001725 510 001726 513 001732 515 001747 516 001754 518 001757 519 001763 520 001771 522 001776 523 001777 524 002000 529 002001 554 002002 555 002004 556 002005 559 002010 565 002047 569 002072 570 002074 571 002077 573 002100 575 002103 576 002105 577 002107 580 002111 581 002126 584 002133 585 002142 587 002145 589 002147 590 002150 591 002152 594 002153 595 002155 598 002211 600 002216 601 002221 603 002222 605 002224 606 002226 609 002262 612 002267 613 002272 616 002273 619 002326 620 002343 623 002344 626 002347 627 002363 629 002364 630 002366 631 002403 632 002407 634 002413 635 002416 636 002423 639 002445 641 002447 642 002452 643 002453 647 002454 648 002457 651 002460 654 002461 656 002466 659 002503 662 002510 663 002512 665 002513 666 002516 ----------------------------------------------------------- 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