COMPILATION LISTING OF SEGMENT window_io_iox_ Compiled by: Multics PL/I Compiler, Release 31a, of October 12, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/17/88 1045.7 mst Mon Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 6* * * 7* *********************************************************** */ 8 9 /* Window_io_iox_ ... line editor and output converter for video */ 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind9 */ 11 12 window_io_iox_: 13 procedure; 14 15 return; 16 17 /* BIM June 1981 */ 18 /* Modified by Chris Jones, December 1981, to add more_mode=fold processing 19* and to remove beep from empty kill */ 20 /* Modified January 1982 by Chris Jones to finish input escape processing 21* and make BS act as an erase character */ 22 /* Modified 26 January 1982 by William York to add user-settable more 23* handlers */ 24 /* Modified 28 April 1982 by WMY to fix a bug in async handling during 25* raw output requests. Added the REPUT_RAW label. */ 26 /* Modified 7 May 1982 by WMY to fix a bug where the call for the second 27* half of a long_record input line reads a new input line from the user 28* instead, and to stop flushing the entire kill ring when CR is typed. */ 29 /* Modified 16 May 1982 by WMY to stop more_mode=fold from crawling up 30* the screen one line at a time, and to make ^L clear the screen before 31* redisplaying the input line (just like ESC ^L), and to put a limit 32* on growth of the kill ring. */ 33 /* Modified 10 September 1982 by WMY to perform a send_buffered_output control 34* order after reading an input line and after processing each put_chars call. 35* This makes tc_ level output buffering less visible to the iox_ caller. */ 36 /* Modified 20 September 1982 by WMY to change the send_buffered_output 37* control order to a window_$sync call. */ 38 /* Modified 1 October 1982 by WMY to make QUIT during more breaks work. */ 39 /* Modified 4 October 1982 by WMY for a complete re-write. Implemented 40* mid-line editing, input line redisplay, etc. */ 41 /* Modified January 1983 by WMY to reset the window status when exiting 42* raw mode. */ 43 /* Modified Februrary 1983 by WMY to add user-settable key bindings. */ 44 /* Modified April 1983 by WMY to fix bugs (no rtrim of output lines and 45* kill merging across CR) and add input conversion support. */ 46 /* Modified April 1983 by WMY to add window_util_ entrypoints for use by 47* external editor routines. */ 48 /* Modified April 1983 by WMY to restructure code so that calls from external 49* editor routines will work correctly. */ 50 /* Modified 6 June 1983 by WMY to try re-sizing the window if a call to 51* window_ gets a out_of_window_bounds error code. The assumption here is 52* that the terminal's screen has shrunk due to reconnection. */ 53 /* Modified 23-24 June 1983 by Jon A. Rochlis to implement numeric arguments 54* to editor routines, stop non-echoed input from being saved on the kill 55* ring, and to give user routines the keysequences which invoked them. */ 56 /* Modified 25 June 1983 by JR to add ESC-L, ESC-U, ESC-C, and ESC-T builtin 57* requests. */ 58 /* Modified 9 October 1983 by JR to add first cut at edit_line */ 59 /* Modified December 1983 by JR to add support for vertical windows. */ 60 /* Modified 1 February 1984 by JR to make the deffault bindings for builtins 61* be case-insensitive. I.e. ESC-f and ESC-F will be bound at init time 62* to FORWARD_WORD. This should make CLJ happy. */ 63 /* Modified 29 February 1984 by Barmar to make free_dispatch_tables 64* externally available */ 65 /* Modified 22 March 1984 by Barmar to make get_line initialize user_data_ptr 66* to null, and to be better at cleaning up. */ 67 /* Modified 29 April 1984 by JR to add LEI.suppress_redisplay. */ 68 /* Modified 27 May 1984 by JR to make async_or_error deal with reconnection 69* and ttp_change status. */ 70 /* Modified 01 September 1984 by JR to support edited mode. */ 71 72 73 /****^ HISTORY COMMENTS: 74* 1) change(86-05-17,GDixon), approve(86-05-17,MCR7357), 75* audit(86-07-10,Farley), install(86-07-18,MR12.0-1098): 76* Change call from tct_$translate to find_char_$translate_first_in_table. 77* The tct_ subroutine was renamed. 78* 2) change(88-09-19,Brunelle), approve(88-09-19,MCR7813), 79* audit(88-10-05,Blair), install(88-10-17,MR12.2-1171): 80* Change convert_special_sequence to return a special char sequence of up to 81* 15 chars instead of 3. This implements special chars version 2 data 82* structure. 83* END HISTORY COMMENTS */ 84 85 86 /* Simulate standard tty stuff in a window */ 87 88 /* Parameters */ 89 90 dcl Iocb_ptr pointer parameter; 91 dcl Buffer_ptr pointer parameter; 92 dcl Buffer_len fixed bin (21) parameter; 93 dcl Code fixed bin (35) parameter; 94 dcl N_returned fixed bin (21) parameter; 95 96 /* Parameters for utility entrypoints */ 97 98 dcl a_lei_ptr pointer parameter; 99 dcl a_count fixed bin (21) parameter; 100 dcl a_kill_direction bit (1) aligned parameter; 101 dcl a_text char (*) parameter; 102 dcl a_code fixed bin (35) parameter; 103 dcl a_table_ptr pointer parameter; 104 105 /* Based */ 106 107 dcl Buffer character (Buffer_len) based (Buffer_ptr); 108 109 /* Automatic */ 110 111 dcl temp_ptr pointer; 112 dcl key_idx fixed bin; 113 dcl get_line_entry_line fixed bin; 114 dcl get_line_entry_column fixed bin; 115 dcl iocb_ptr pointer; 116 dcl number_to_save fixed bin (21); 117 dcl char_varying char (1) varying; 118 dcl char_nonvarying char (1); 119 dcl char_count fixed bin; 120 dcl code fixed bin (35); 121 122 dcl redisplay_buffer_ptr pointer; /* This buffer is made to be 4 times longer than the input buffer in 123* line_editor_info. */ 124 dcl redisplay_buffer char (2048) based (redisplay_buffer_ptr); 125 126 dcl window_line_used_ptr pointer; 127 dcl WINDOW_LINE_USED (attach_data.current.rows) bit (1) based (window_line_used_ptr); 128 129 dcl lei_ptr pointer; 130 131 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 132 133 dcl 1 automatic_line_editor_info 134 aligned like line_editor_info; 135 136 dcl saved_buffer_length fixed bin; 137 138 dcl 1 saved_buffer aligned based (attach_data.saved_buffer_ptr), 139 2 saved_length fixed bin, 140 2 text char (saved_buffer_length refer (saved_buffer.saved_length)) varying; 141 142 /* Global variables. */ 143 144 dcl REAL_CL_INTERMEDIARY entry (1 structure aligned, 2 bit (1) unaligned, 2 bit (35) unaligned) variable; 145 dcl BREAKS_CHANGED bit (1); 146 dcl SAVED_BREAKS bit (128) unaligned; 147 dcl ASYNC_EVENT label variable local; 148 dcl ERROR_COUNT fixed bin; 149 dcl PROCESSED_SO_FAR fixed bin; 150 151 dcl cleanup condition; 152 153 /* Constants */ 154 155 dcl TEN_SPACES char (10) static options (constant) init (" "); 156 dcl CONTINUATION_CHARS char (2) static options (constant) init ("\c"); 157 dcl FORWARD_KILL bit (1) aligned static options (constant) init ("0"b); 158 dcl BACKWARD_KILL bit (1) aligned static options (constant) init ("1"b); 159 dcl NL char (1) static options (constant) init (" 160 "); 161 dcl DEL char (1) static options (constant) init (""); 162 dcl BELL char (1) static options (constant) init (""); 163 dcl uppercase char (26) static options (constant) init ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); 164 dcl lowercase char (26) static options (constant) init ("abcdefghijklmnopqrstuvwxyz"); 165 166 /* External */ 167 168 dcl ( 169 error_table_$long_record, 170 error_table_$action_not_performed, 171 error_table_$unimplemented_version, 172 error_table_$bad_subr_arg, 173 video_et_$window_status_pending, 174 video_et_$out_of_window_bounds, 175 video_et_$cursor_position_undefined, 176 video_et_$capability_lacking 177 ) ext static fixed bin (35); 178 179 /* Builtins */ 180 181 dcl (addcharno, addr, bin, byte, copy, divide, fixed, index, length, max, maxlength, min, mod, null, rank, reverse, 182 rtrim, search, sign, string, substr, translate, unspec, verify) 183 builtin; 184 185 /* Entries */ 186 187 dcl cu_$get_cl_intermediary 188 entry (entry); 189 dcl cu_$set_cl_intermediary 190 entry (entry); 191 192 nulle: /* borrow as reference entry variable */ 193 init: 194 entry (Iocb_ptr); 195 196 iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr; 197 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 198 199 attach_data.saved_buffer_ptr = null (); 200 201 allocate dispatch_table set (dispatch_table_ptr); 202 203 /* First make all non-printing keys unbound. */ 204 dispatch_table.key (*).type = UNDEFINED; 205 dispatch_table.key (127).type = UNDEFINED; 206 207 /* Now get the self-inserts. */ 208 do key_idx = 32 to 126; 209 dispatch_table.key (key_idx).type = SELF_INSERT; 210 end; 211 212 dispatch_table.key (1).type = MOVE_TO_BEGINNING_OF_LINE; 213 /* ^A */ 214 dispatch_table.key (2).type = BACKWARD_CHARACTER; /* ^B */ 215 dispatch_table.key (4).type = FORWARD_DELETE_CHARACTER; 216 /* ^D */ 217 dispatch_table.key (5).type = MOVE_TO_END_OF_LINE;/* ^E */ 218 dispatch_table.key (6).type = FORWARD_CHARACTER; /* ^F */ 219 dispatch_table.key (8).type = BACKWARD_DELETE_CHARACTER; 220 /* ^H */ 221 dispatch_table.key (9).type = SELF_INSERT; /* ^I */ 222 dispatch_table.key (10).type = TERMINATE_INPUT_LINE; 223 /* ^J */ 224 dispatch_table.key (11).type = KILL_TO_END_OF_LINE; 225 /* ^K */ 226 dispatch_table.key (12).type = CLEAR_WINDOW; /* ^L */ 227 dispatch_table.key (13).type = TERMINATE_INPUT_LINE; 228 /* ^M */ 229 dispatch_table.key (17).type = QUOTE_CHARACTER; /* ^Q */ 230 dispatch_table.key (20).type = TWIDDLE_CHARACTERS;/* ^T */ 231 dispatch_table.key (21).type = MULTIPLIER; /* ^U */ 232 dispatch_table.key (25).type = YANK_FROM_KILL_RING; 233 /* ^Y */ 234 dispatch_table.key (31).type = DISPLAY_EDITOR_DOCUMENTATION; 235 /* ^_ */ 236 dispatch_table.key (127).type = BACKWARD_DELETE_CHARACTER; 237 /* DEL */ 238 239 dispatch_table.key (rank (attach_data.kill_char)).type = KILL_TO_BEGINNING_OF_LINE; 240 dispatch_table.key (rank (attach_data.erase_char)).type = BACKWARD_DELETE_CHARACTER; 241 dispatch_table.key (rank (attach_data.input_escape_char)).type = PROCESS_INPUT_ESCAPE; 242 243 dispatch_table.name (*), dispatch_table.description (*), dispatch_table.info_dir (*), 244 dispatch_table.info_entry (*) = ""; 245 246 attach_data.dispatch_table_ptr = dispatch_table_ptr; 247 248 /* Allocate a second-level dispatch table for ESC prefix */ 249 allocate dispatch_table set (temp_ptr); 250 251 /* Start out with all unbound. */ 252 temp_ptr -> dispatch_table.key (*).type = UNDEFINED; 253 254 dispatch_table.key (27).next_table = temp_ptr; 255 dispatch_table.key (27).type = -1; 256 257 dispatch_table_ptr = temp_ptr; 258 259 /* Fill in ESC prefix values. */ 260 261 dispatch_table.key (rank ("0")).type = NUMBER_READER_0; 262 dispatch_table.key (rank ("1")).type = NUMBER_READER_1; 263 dispatch_table.key (rank ("2")).type = NUMBER_READER_2; 264 dispatch_table.key (rank ("3")).type = NUMBER_READER_3; 265 dispatch_table.key (rank ("4")).type = NUMBER_READER_4; 266 dispatch_table.key (rank ("5")).type = NUMBER_READER_5; 267 dispatch_table.key (rank ("6")).type = NUMBER_READER_6; 268 dispatch_table.key (rank ("7")).type = NUMBER_READER_7; 269 dispatch_table.key (rank ("8")).type = NUMBER_READER_8; 270 dispatch_table.key (rank ("9")).type = NUMBER_READER_9; 271 dispatch_table.key (rank ("-")).type = NEGATIVE_NUMBER_READER; 272 273 dispatch_table.key (rank ("b")).type = BACKWARD_WORD; 274 dispatch_table.key (rank ("c")).type = INITIAL_CAPITAL; 275 dispatch_table.key (rank ("d")).type = FORWARD_DELETE_WORD; 276 dispatch_table.key (rank ("f")).type = FORWARD_WORD; 277 dispatch_table.key (rank ("l")).type = LOWERCASE_WORD; 278 dispatch_table.key (rank ("t")).type = TWIDDLE_WORDS; 279 dispatch_table.key (rank ("u")).type = UPPERCASE_WORD; 280 dispatch_table.key (rank ("y")).type = YANK_PREVIOUS_FROM_KILL_RING; 281 282 dispatch_table.key (rank ("B")).type = BACKWARD_WORD; 283 dispatch_table.key (rank ("C")).type = INITIAL_CAPITAL; 284 dispatch_table.key (rank ("D")).type = FORWARD_DELETE_WORD; 285 dispatch_table.key (rank ("F")).type = FORWARD_WORD; 286 dispatch_table.key (rank ("L")).type = LOWERCASE_WORD; 287 dispatch_table.key (rank ("T")).type = TWIDDLE_WORDS; 288 dispatch_table.key (rank ("U")).type = UPPERCASE_WORD; 289 dispatch_table.key (rank ("Y")).type = YANK_PREVIOUS_FROM_KILL_RING; 290 291 dispatch_table.key (rank ("?")).type = DISPLAY_EDITOR_DOCUMENTATION; 292 dispatch_table.key (rank ("")).type = BACKWARD_DELETE_WORD; 293 dispatch_table.key (rank (attach_data.erase_char)).type = BACKWARD_DELETE_WORD; 294 295 dispatch_table.name (*), dispatch_table.description (*), dispatch_table.info_dir (*), 296 dispatch_table.info_entry (*) = ""; 297 298 return; 299 300 shut: 301 entry (Iocb_ptr); 302 303 iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr; 304 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 305 306 call free_dispatch_tables (attach_data.dispatch_table_ptr); 307 308 if attach_data.saved_buffer_ptr ^= null () then 309 free attach_data.saved_buffer_ptr -> saved_buffer; 310 311 return; 312 313 free_dispatch_tables: 314 entry (a_table_ptr); 315 316 do key_idx = 0 to 127; 317 if a_table_ptr -> dispatch_table.key (key_idx).type = -1 then 318 call free_dispatch_tables (a_table_ptr -> dispatch_table.key (key_idx).next_table); 319 end; 320 321 free a_table_ptr -> dispatch_table; 322 323 return; 324 325 326 /* So much for the easy stuff */ 327 328 edit_line: 329 entry (Iocb_ptr, Window_edit_line_info_ptr, Buffer_ptr, Buffer_len, N_returned, Code); 330 331 declare Window_edit_line_info_ptr 332 pointer parameter; 333 334 window_edit_line_info_ptr = Window_edit_line_info_ptr; 335 336 if window_edit_line_info.version ^= window_edit_line_info_version_1 then do; 337 Code = error_table_$unimplemented_version; 338 return; 339 end; 340 341 if window_edit_line_info.line_length < 0 then do; 342 Code = error_table_$bad_subr_arg; 343 return; 344 end; 345 346 goto GET_LINE_COMMON; 347 348 get_line: 349 entry (Iocb_ptr, Buffer_ptr, Buffer_len, N_returned, Code); 350 351 window_edit_line_info_ptr = null (); 352 353 GET_LINE_COMMON: 354 iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr; 355 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 356 357 Code = 0; 358 N_returned = 0; 359 360 /* Perform a reset_more. */ 361 attach_data.discard_output = "0"b; 362 363 /* Now make sure that the next async output won't more break once 364* the user has entered the input line editor. */ 365 attach_data.lines_written_since_read = 0; 366 367 if Buffer_len = 0 | Buffer_ptr = null () then 368 return; 369 370 /* Is there stuff left over from last time? If so, just 371* return the old stuff. This call must have occurred after one 372* which returned error_table_$long_record. */ 373 374 if attach_data.saved_buffer_ptr ^= null () then do; 375 N_returned = min (Buffer_len, length (saved_buffer.text)); 376 substr (Buffer, 1, N_returned) = substr (saved_buffer.text, 1, N_returned); 377 378 /* Still couldn't take it all? */ 379 if Buffer_len < length (saved_buffer.text) then do; 380 saved_buffer.text = substr (saved_buffer.text, N_returned + 1); 381 Code = error_table_$long_record; 382 end; 383 else do; 384 free attach_data.saved_buffer_ptr -> saved_buffer; 385 attach_data.saved_buffer_ptr = null (); 386 end; 387 return; 388 end; 389 390 /* Get pointer to automatic storage copy of editor state. */ 391 lei_ptr = addr (automatic_line_editor_info); 392 393 LEI.version = line_editor_info_version_2; 394 LEI.iocb_ptr = iocb_ptr; 395 LEI.repetition_count = 1; 396 LEI.numarg_given = "0"b; 397 LEI.return_from_editor = "0"b; 398 LEI.suppress_redisplay = "0"b; /* redisplay unless the editor routine says otherwise */ 399 LEI.line_length = 0; 400 LEI.cursor_index = 1; 401 LEI.input_buffer = ""; 402 LEI.merge_next_kill = "0"b; 403 LEI.old_merge_next_kill = "0"b; 404 LEI.last_kill_direction = "0"b; 405 LEI.user_data_ptr = null (); 406 407 /* Put the initial text in the buffer if we were called 408* via edit_line */ 409 410 if window_edit_line_info_ptr ^= null () then do; 411 if window_edit_line_info.line_length ^= 0 then do; 412 begin; 413 dcl initial_text char (window_edit_line_info.line_length) based (window_edit_line_info.line_ptr); 414 call insert_in_buffer (lei_ptr, initial_text, Code); 415 if Code ^= 0 then 416 return; 417 LEI.cursor_index = 1; /* back to the start of the line */ 418 window_edit_line_info_ptr = null (); 419 /* don't do this again */ 420 end; /* begin */ 421 end; 422 end; 423 424 /* Set up the global state variables. */ 425 get_line_entry_line = attach_data.line; 426 get_line_entry_column = attach_data.col; 427 428 ERROR_COUNT = 0; 429 BREAKS_CHANGED = "0"b; 430 SAVED_BREAKS = attach_data.breaks; 431 REAL_CL_INTERMEDIARY = nulle; 432 433 redisplay_buffer_ptr = null (); 434 window_line_used_ptr = null (); 435 436 on cleanup call get_line_cleanup (); 437 438 /* the cleanup handler is established, allocate storage */ 439 alloc WINDOW_LINE_USED set (window_line_used_ptr); 440 alloc redisplay_buffer set (redisplay_buffer_ptr); 441 442 /* when something async happens in this window, go to this label */ 443 444 ASYNC_EVENT = RESTART_GET_LINE; 445 446 /* We change the cl_intermediary so that we can detect screen 447* changes caused by pushing new levels. */ 448 449 call cu_$get_cl_intermediary (REAL_CL_INTERMEDIARY); 450 call cu_$set_cl_intermediary (cl_pusher); 451 452 /* Check for window status or undefined cursor. */ 453 454 call window_$position_cursor_rel (iocb_ptr, 0, 0, code); 455 if code = video_et_$window_status_pending then do; 456 if attach_data.status.reconnection | attach_data.status.ttp_change then call resize_window(); 457 attach_data.status_pending = "0"b; 458 string (attach_data.status) = ""b; 459 end; 460 else if code = video_et_$cursor_position_undefined/* define it -- assume we did rawo mode */ 461 then do; 462 call window_$position_cursor (iocb_ptr, attach_data.row_at_rawo, attach_data.col_at_rawo, code); 463 call async_or_error (code); 464 end; 465 else if code ^= 0 then do; /* who knows what happened? */ 466 Code = code; 467 go to return_from_get_line; /* So we free everything */ 468 end; 469 470 /* Read and buffer an input line. The buffer always end with a linefeed, 471* since we talk to the user till we get one */ 472 473 get_input_line: 474 call read_input_line (lei_ptr); 475 476 /* Now we have a whole input line. Save it in the kill ring. */ 477 478 number_to_save = LEI.line_length; 479 if substr (LEI.input_buffer, LEI.line_length, 1) = NL then 480 number_to_save = number_to_save - 1; 481 482 if number_to_save > 0 then do; 483 LEI.old_merge_next_kill = "0"b; 484 if ^attach_data.suppress_echo then 485 call add_to_kill_ring (lei_ptr, 1, number_to_save, FORWARD_KILL); 486 end; 487 488 /* Return entire line or until caller's buffer fills. */ 489 490 N_returned = min (Buffer_len, LEI.line_length); 491 492 substr (Buffer, 1, N_returned) = substr (LEI.input_buffer, 1, N_returned); 493 LEI.line_length = LEI.line_length - N_returned; 494 495 if LEI.line_length > 0 then do; /* Caller can't take all the input available, so save the 496* rest until he calls in again. */ 497 498 saved_buffer_length = LEI.line_length; 499 allocate saved_buffer set (attach_data.saved_buffer_ptr); 500 501 saved_buffer.text = substr (LEI.input_buffer, N_returned + 1, LEI.line_length); 502 Code = error_table_$long_record; 503 end; 504 505 /* Start counting output lines from here. */ 506 attach_data.lines_written_since_read = 0; 507 508 call window_$sync (iocb_ptr, code); /* don't check code, we're on the way out anyway. */ 509 510 return_from_get_line: 511 call get_line_cleanup (); 512 return; 513 514 get_line_cleanup: 515 procedure; 516 517 declare 1 b aligned like break_table_info; 518 519 if redisplay_buffer_ptr ^= null () then 520 free redisplay_buffer; 521 522 if window_line_used_ptr ^= null () then 523 free WINDOW_LINE_USED; 524 525 if REAL_CL_INTERMEDIARY ^= nulle then 526 call cu_$set_cl_intermediary (REAL_CL_INTERMEDIARY); 527 528 if BREAKS_CHANGED then do; 529 b.version = break_table_info_version; 530 string(b.breaks) = SAVED_BREAKS; 531 call iox_$control (iocb_ptr, "set_break_table", addr (b), (0)); 532 BREAKS_CHANGED = "0"b; 533 end; 534 535 if LEI.user_data_ptr ^= null then 536 call free_user_data (LEI.user_data_ptr); 537 538 return; 539 540 end get_line_cleanup; 541 542 543 RESTART_GET_LINE: /* Prepnl */ 544 if attach_data.col ^= 1 then 545 call get_to_next_line; 546 547 /* reset the origin to current position */ 548 549 get_line_entry_line = attach_data.line; 550 get_line_entry_column = attach_data.col; 551 552 goto get_input_line; 553 554 555 free_user_data: 556 procedure (leud_ptr); 557 558 dcl leud_ptr pointer parameter; /* always non-null */ 559 560 dcl temp_ptr ptr; 561 dcl freen_ entry (ptr); /* Since we only have a pointers to structure headers */ 562 dcl 1 LEUDH aligned like line_editor_user_data_header based (leud_ptr); 563 564 do while (leud_ptr ^= null ()); 565 temp_ptr = LEUDH.next_user_data_ptr; 566 call freen_ (leud_ptr); 567 leud_ptr = temp_ptr; 568 end; 569 570 return; 571 end free_user_data; 572 573 /* Routine to set the screen image to the current stuff on the screen. */ 574 initialize_window_image: 575 procedure; 576 577 dcl line_idx fixed bin; 578 dcl code fixed bin (35); 579 580 call iox_$control (attach_data.target_iocb_ptr, "get_screen_image_ptr", screen_ptr, code); 581 call async_or_error (code); 582 583 do line_idx = 1 to attach_data.current.rows; 584 window_image (line_idx) = 585 substr (screen.lines (line_idx + attach_data.current.line_origin - 1), attach_data.column_origin, 586 attach_data.current.columns); /* be sure to only get the stuff that is in our window */ 587 end; 588 589 WINDOW_LINE_USED = "0"b; /* Clear whole array. */ 590 return; 591 end initialize_window_image; 592 593 /* Routine to read input, processing editor requests, until a newline is 594* typed. May be called with a partially filled buffer if an async event 595* occurrs. */ 596 597 read_input_line: 598 procedure (lei_ptr); 599 600 dcl lei_ptr pointer parameter; 601 602 dcl break_char character (1) varying; 603 dcl number_returned fixed bin (21); 604 dcl number_to_read fixed bin (21); 605 dcl (read_start_line, read_start_column) 606 fixed bin; 607 dcl code fixed bin (35); 608 609 /* this dcl limits us to terminals with screens narrower than 1024 chars */ 610 dcl read_buffer char (1024); 611 612 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 613 614 615 /* First include whatever async output may be on the screen. */ 616 call initialize_window_image (); 617 618 if LEI.line_length > 0 /* if there is old stuff, redisplay */ 619 then call redisplay_input_line (lei_ptr); 620 621 do while ("1"b); /* process_break will exit us */ 622 623 /* How much screen left on this line? (and in the window!) */ 624 number_to_read = attach_data.current.columns - attach_data.col + 1; 625 number_returned = 0; 626 break_char = ""; 627 628 read_start_line = attach_data.line; 629 read_start_column = attach_data.col; 630 631 /* If buffer is full, do not echo negotiate. We will eventually 632* execute a request that deletes some stuff from the buffer. */ 633 if LEI.line_length >= length (LEI.input_buffer) then do; 634 call window_$get_one_unechoed (iocb_ptr, break_char, "1"b, code); 635 call async_or_error (code); 636 end; 637 638 else do; /* If buffer is almost full, read fewer chars. */ 639 number_to_read = min (number_to_read, length (LEI.input_buffer) - LEI.line_length); 640 641 /* If we are in the middle of the line or up against 642* the right edge of the window, or echoing is off, 643* read single chars */ 644 645 if (LEI.cursor_index <= LEI.line_length) | (number_to_read <= 0) | attach_data.suppress_echo then 646 call window_$get_one_unechoed (iocb_ptr, break_char, "1"b, code); 647 else do; /* Put line editor breaks in effect. */ 648 BREAKS_CHANGED = "1"b; 649 SAVED_BREAKS = attach_data.breaks; 650 attach_data.breaks = attach_data.line_editor_breaks; 651 call window_$get_echoed_chars (iocb_ptr, number_to_read, read_buffer, number_returned, 652 break_char, code); 653 654 attach_data.breaks = SAVED_BREAKS; 655 BREAKS_CHANGED = "0"b; 656 end; 657 end; 658 659 call async_or_error (code); 660 661 /* Process any echoed characters. */ 662 663 if number_returned > 0 then do; 664 665 LEI.merge_next_kill = "0"b; 666 667 /* Add negotiated characters to input buffer. */ 668 669 begin; 670 dcl echoed_chars char (number_returned) defined (read_buffer) position (1); 671 call insert_in_buffer (lei_ptr, echoed_chars, code); 672 673 if code ^= 0 then 674 call ring (); 675 676 call add_to_window_image (echoed_chars, read_start_line, read_start_column); 677 end; 678 end; 679 680 /* Check length, since a char(1) varying containing a space 681* compares equal to "" */ 682 683 if length (break_char) > 0 then do; 684 LEI.repetition_count = 1; 685 LEI.numarg_given = "0"b; 686 call process_break (lei_ptr, break_char); 687 if LEI.return_from_editor then do; 688 if ^LEI.suppress_redisplay then do; 689 call redisplay_input_line (lei_ptr); 690 call get_to_next_line; /* should this always be done? We really need window_editor_utils_$redisplay_input_line ... sigh --- JR 5/3/84 */ 691 end; 692 return; 693 end; 694 end; 695 696 call redisplay_input_line (lei_ptr); 697 698 end; /* do while */ 699 700 return; 701 end read_input_line; 702 703 /* The guts of the editor. This routine interprets editor requests. */ 704 705 process_break: 706 procedure (lei_ptr, break_char); 707 708 dcl lei_ptr pointer parameter; 709 dcl break_char char (1) varying parameter; 710 711 dcl break char (1); 712 dcl temp_char_varying char (1) varying; 713 dcl code fixed bin (35); 714 715 dcl (i, repeat_count) fixed bin; 716 dcl numarg_action fixed bin; 717 dcl editor_routine entry (pointer /* lei_ptr */, fixed bin (35) /* code */) variable; 718 719 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 720 721 break = break_char; 722 723 dispatch_table_ptr = attach_data.dispatch_table_ptr; 724 725 LEI.key_sequence = break; 726 727 /* Hack META characters. For now we will define META characters 728* to simply look up the dispatch table hanging off the ESC key. 729* If there is none, you lose. */ 730 731 if (break > DEL) then do; /* Make sure that there is a META table */ 732 if dispatch_table.key (27).type < 0 then 733 dispatch_table_ptr = dispatch_table.key (27).next_table; 734 else do; 735 call window_$bell (iocb_ptr, code); 736 call async_or_error (code); 737 return; 738 end; 739 740 /* Turn off META bit. */ 741 break = byte (rank (break) - 128); 742 end; 743 744 /* chase through prefix sequences to terminal character */ 745 do while (dispatch_table.key (rank (break)).type < 0); 746 dispatch_table_ptr = dispatch_table.key (rank (break)).next_table; 747 call window_$get_one_unechoed (iocb_ptr, temp_char_varying, "1"b, code); 748 call async_or_error (code); 749 break = temp_char_varying; 750 LEI.key_sequence = rtrim (LEI.key_sequence) || break; 751 end; 752 753 if dispatch_table.key (rank (break)).type ^= 0 then 754 goto builtin_requests (dispatch_table.key (rank (break)).type); 755 else do; 756 editor_routine = dispatch_table.key (rank (break)).routine; 757 numarg_action = dispatch_table.key (rank (break)).numarg_action; 758 end; 759 760 do_editor_request: 761 repeat_count = 1; 762 763 if numarg_action = REPEAT & LEI.numarg_given & LEI.repetition_count < 0 then do; 764 code = error_table_$action_not_performed; 765 goto editor_request_finish; 766 end; 767 768 if numarg_action = REPEAT & LEI.numarg_given then 769 repeat_count = LEI.repetition_count; 770 771 if numarg_action = REJECT & LEI.numarg_given then do; 772 code = error_table_$action_not_performed; 773 goto editor_request_finish; 774 end; 775 776 777 do i = 1 to repeat_count; 778 779 LEI.old_merge_next_kill = LEI.merge_next_kill; 780 LEI.merge_next_kill = "0"b; 781 782 call editor_routine (lei_ptr, code); 783 if code ^= 0 then 784 goto editor_request_finish; 785 786 if dispatch_table.key (rank (break)).type = 0 then do; 787 /* Try to ensure consistent state */ 788 if LEI.line_length < 0 then 789 LEI.line_length = 0; 790 if LEI.line_length > length (LEI.input_buffer) then 791 LEI.line_length = length (LEI.input_buffer); 792 if LEI.cursor_index < 1 then 793 LEI.cursor_index = 1; 794 if LEI.cursor_index > LEI.line_length + 1 then 795 LEI.cursor_index = LEI.line_length + 1; 796 end; 797 end; /* do loop */ 798 799 editor_request_finish: 800 if code = error_table_$action_not_performed then 801 call ring (); 802 803 return; 804 805 /* This label array defines the values of the type field of the dispatch 806* table */ 807 808 builtin_requests (1): 809 editor_routine = forward_character; 810 numarg_action = REPEAT; 811 goto do_editor_request; 812 813 builtin_requests (2): 814 editor_routine = backward_character; 815 numarg_action = REPEAT; 816 goto do_editor_request; 817 818 builtin_requests (3): 819 editor_routine = forward_delete_character; 820 numarg_action = REPEAT; 821 goto do_editor_request; 822 823 builtin_requests (4): 824 editor_routine = backward_delete_character; 825 numarg_action = REPEAT; 826 goto do_editor_request; 827 828 builtin_requests (5): 829 editor_routine = move_to_end_of_line; 830 numarg_action = IGNORE; 831 goto do_editor_request; 832 833 builtin_requests (6): 834 editor_routine = move_to_beginning_of_line; 835 numarg_action = IGNORE; 836 goto do_editor_request; 837 838 builtin_requests (7): 839 editor_routine = kill_to_end_of_line; 840 numarg_action = IGNORE; 841 goto do_editor_request; 842 843 builtin_requests (8): 844 editor_routine = kill_to_beginning_of_line; 845 numarg_action = IGNORE; 846 goto do_editor_request; 847 848 builtin_requests (9): 849 editor_routine = forward_word; 850 numarg_action = REPEAT; 851 goto do_editor_request; 852 853 builtin_requests (10): 854 editor_routine = backward_word; 855 numarg_action = REPEAT; 856 goto do_editor_request; 857 858 builtin_requests (11): 859 editor_routine = forward_delete_word; 860 numarg_action = REPEAT; 861 goto do_editor_request; 862 863 builtin_requests (12): 864 editor_routine = backward_delete_word; 865 numarg_action = REPEAT; 866 goto do_editor_request; 867 868 builtin_requests (13): 869 editor_routine = quote_character; 870 numarg_action = PASS; 871 goto do_editor_request; 872 873 builtin_requests (14): 874 editor_routine = clear_window; 875 numarg_action = IGNORE; 876 goto do_editor_request; 877 878 builtin_requests (15): 879 editor_routine = twiddle_characters; 880 numarg_action = IGNORE; 881 goto do_editor_request; 882 883 builtin_requests (16): 884 editor_routine = display_editor_documentation; 885 numarg_action = IGNORE; 886 goto do_editor_request; 887 888 builtin_requests (17): 889 editor_routine = self_insert; 890 numarg_action = REPEAT; 891 goto do_editor_request; 892 893 builtin_requests (18): 894 editor_routine = yank_from_kill_ring; 895 numarg_action = IGNORE; 896 goto do_editor_request; 897 898 builtin_requests (19): 899 editor_routine = yank_previous_from_kill_ring; 900 numarg_action = IGNORE; 901 goto do_editor_request; 902 903 builtin_requests (20): 904 editor_routine = terminate_input_line; 905 numarg_action = IGNORE; 906 goto do_editor_request; 907 908 builtin_requests (21): /* Unimplemented requests, etc. */ 909 editor_routine = ring; 910 numarg_action = IGNORE; 911 goto do_editor_request; 912 913 builtin_requests (22): 914 editor_routine = process_input_escape; 915 numarg_action = IGNORE; 916 goto do_editor_request; 917 918 builtin_requests (23): 919 editor_routine = number_reader_0; 920 numarg_action = PASS; 921 goto do_editor_request; 922 923 builtin_requests (24): 924 editor_routine = number_reader_1; 925 numarg_action = PASS; 926 goto do_editor_request; 927 928 builtin_requests (25): 929 editor_routine = number_reader_2; 930 numarg_action = PASS; 931 goto do_editor_request; 932 933 builtin_requests (26): 934 editor_routine = number_reader_3; 935 numarg_action = PASS; 936 goto do_editor_request; 937 938 builtin_requests (27): 939 editor_routine = number_reader_4; 940 numarg_action = PASS; 941 goto do_editor_request; 942 943 builtin_requests (28): 944 editor_routine = number_reader_5; 945 numarg_action = PASS; 946 goto do_editor_request; 947 948 builtin_requests (29): 949 editor_routine = number_reader_6; 950 numarg_action = PASS; 951 goto do_editor_request; 952 953 builtin_requests (30): 954 editor_routine = number_reader_7; 955 numarg_action = PASS; 956 goto do_editor_request; 957 958 builtin_requests (31): 959 editor_routine = number_reader_8; 960 numarg_action = PASS; 961 goto do_editor_request; 962 963 builtin_requests (32): 964 editor_routine = number_reader_9; 965 numarg_action = PASS; 966 goto do_editor_request; 967 968 builtin_requests (33): 969 editor_routine = multiplier; 970 numarg_action = PASS; 971 goto do_editor_request; 972 973 builtin_requests (34): 974 editor_routine = lowercase_word; 975 numarg_action = PASS; 976 goto do_editor_request; 977 978 builtin_requests (35): 979 editor_routine = uppercase_word; 980 numarg_action = PASS; 981 goto do_editor_request; 982 983 builtin_requests (36): 984 editor_routine = initial_capital; 985 numarg_action = PASS; 986 goto do_editor_request; 987 988 builtin_requests (37): 989 editor_routine = twiddle_words; 990 numarg_action = IGNORE; 991 goto do_editor_request; 992 993 builtin_requests (38): 994 editor_routine = negative_number_reader; 995 numarg_action = PASS; 996 goto do_editor_request; 997 998 end process_break; 999 1000 /* External entrypoints for user-defined editor routines. */ 1001 1002 insert_text_: 1003 entry (a_lei_ptr, a_text, a_code); 1004 1005 call setup_util_call; 1006 1007 call insert_in_buffer (a_lei_ptr, a_text, a_code); 1008 return; 1009 1010 delete_text_: 1011 entry (a_lei_ptr, a_count, a_code); 1012 1013 call setup_util_call; 1014 1015 call delete_from_buffer (a_lei_ptr, a_count, a_code); 1016 return; 1017 1018 delete_text_save_: 1019 entry (a_lei_ptr, a_count, a_kill_direction, a_code); 1020 1021 call setup_util_call; 1022 1023 call delete_from_buffer_save (a_lei_ptr, a_count, a_kill_direction, a_code); 1024 return; 1025 1026 move_forward_: 1027 entry (a_lei_ptr, a_count, a_code); 1028 1029 a_code = 0; 1030 call setup_util_call; 1031 1032 if (a_lei_ptr -> line_editor_info.cursor_index + a_count) > a_lei_ptr -> line_editor_info.line_length + 1 then 1033 a_code = error_table_$action_not_performed; 1034 else a_lei_ptr -> line_editor_info.cursor_index = a_lei_ptr -> line_editor_info.cursor_index + a_count; 1035 1036 return; 1037 1038 move_backward_: 1039 entry (a_lei_ptr, a_count, a_code); 1040 1041 a_code = 0; 1042 call setup_util_call; 1043 1044 if (a_lei_ptr -> line_editor_info.cursor_index - a_count) < 1 then 1045 a_code = error_table_$action_not_performed; 1046 else a_lei_ptr -> line_editor_info.cursor_index = a_lei_ptr -> line_editor_info.cursor_index - a_count; 1047 1048 return; 1049 1050 move_forward_word_: 1051 entry (a_lei_ptr, a_code); 1052 1053 call setup_util_call; 1054 1055 call forward_word (a_lei_ptr, a_code); 1056 return; 1057 1058 move_backward_word_: 1059 entry (a_lei_ptr, a_code); 1060 1061 call setup_util_call; 1062 1063 call backward_word (a_lei_ptr, a_code); 1064 return; 1065 1066 get_top_kill_ring_element_: 1067 entry (a_lei_ptr, a_text, a_code); 1068 1069 call setup_util_call; 1070 1071 a_text = killer.words; 1072 return; 1073 1074 rotate_kill_ring_: 1075 entry (a_lei_ptr, a_code); 1076 1077 call setup_util_call; 1078 1079 call rotate_kill_ring (); 1080 1081 util_call_return: 1082 return; 1083 1084 /* Routine to setup data pointers for external routine utility entrypoints. 1085* Callers must have a_lei_ptr and a_code as parameters. */ 1086 1087 setup_util_call: 1088 procedure; 1089 1090 dcl error_table_$null_info_ptr 1091 fixed bin (35) ext static; 1092 dcl error_table_$unimplemented_version 1093 fixed bin (35) external static; 1094 1095 if a_lei_ptr = null () then do; 1096 a_code = error_table_$null_info_ptr; 1097 goto util_call_return; 1098 end; 1099 1100 if a_lei_ptr -> line_editor_info.version ^= line_editor_info_version_2 then do; 1101 a_code = error_table_$unimplemented_version; 1102 goto util_call_return; 1103 end; 1104 1105 iocb_ptr = a_lei_ptr -> line_editor_info.iocb_ptr -> iocb.actual_iocb_ptr; 1106 1107 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 1108 1109 return; 1110 1111 end setup_util_call; 1112 1113 /* Utilities that actually implement the editor routines */ 1114 1115 self_insert: /* this will work for more than one char! But is it the right thing??? */ 1116 procedure (lei_ptr, code); 1117 1118 dcl lei_ptr pointer parameter; 1119 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1120 dcl code fixed bin (35); 1121 1122 code = 0; 1123 if LEI.key_sequence = "" /* spaces? */ 1124 then call insert_in_buffer (lei_ptr, " ", code); 1125 else call insert_in_buffer (lei_ptr, rtrim (LEI.key_sequence), code); 1126 1127 end self_insert; 1128 1129 backward_delete_character: 1130 procedure (lei_ptr, code); 1131 1132 dcl lei_ptr pointer parameter; 1133 dcl code fixed bin (35); 1134 1135 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1136 1137 code = 0; 1138 if LEI.cursor_index > 1 then do; 1139 LEI.cursor_index = LEI.cursor_index - 1; 1140 call delete_from_buffer (lei_ptr, 1, code); 1141 end; 1142 else code = error_table_$action_not_performed; 1143 1144 end backward_delete_character; 1145 1146 kill_to_beginning_of_line: 1147 procedure (lei_ptr, code); 1148 1149 dcl lei_ptr pointer parameter; 1150 dcl code fixed bin (35); 1151 1152 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1153 1154 dcl old_cursor fixed bin (21); 1155 1156 code = 0; 1157 old_cursor = LEI.cursor_index; 1158 LEI.cursor_index = 1; 1159 call delete_from_buffer_save (lei_ptr, old_cursor - 1, BACKWARD_KILL, code); 1160 return; 1161 1162 end kill_to_beginning_of_line; 1163 1164 backward_character: 1165 procedure (lei_ptr, code); 1166 1167 dcl lei_ptr pointer parameter; 1168 dcl code fixed bin (35) parameter; 1169 1170 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1171 1172 code = 0; 1173 if LEI.cursor_index > 1 then 1174 LEI.cursor_index = LEI.cursor_index - 1; 1175 1176 end backward_character; 1177 1178 forward_character: 1179 procedure (lei_ptr, code); 1180 1181 dcl lei_ptr pointer parameter; 1182 dcl code fixed bin (35) parameter; 1183 1184 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1185 1186 code = 0; 1187 if LEI.cursor_index < (LEI.line_length + 1) then 1188 LEI.cursor_index = LEI.cursor_index + 1; 1189 1190 end forward_character; 1191 1192 move_to_beginning_of_line: 1193 procedure (lei_ptr, code); 1194 1195 dcl lei_ptr pointer parameter; 1196 dcl code fixed bin (35) parameter; 1197 1198 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1199 1200 code = 0; 1201 LEI.cursor_index = 1; 1202 1203 end move_to_beginning_of_line; 1204 1205 move_to_end_of_line: 1206 procedure (lei_ptr, code); 1207 1208 dcl lei_ptr pointer parameter; 1209 dcl code fixed bin (35); 1210 1211 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1212 1213 code = 0; 1214 LEI.cursor_index = LEI.line_length + 1; 1215 1216 end move_to_end_of_line; 1217 1218 forward_delete_character: 1219 procedure (lei_ptr, code); 1220 1221 dcl lei_ptr pointer parameter; 1222 dcl code fixed bin (35); 1223 1224 code = 0; 1225 call delete_from_buffer (lei_ptr, 1, code); 1226 1227 end forward_delete_character; 1228 1229 kill_to_end_of_line: 1230 procedure (lei_ptr, code); 1231 1232 dcl lei_ptr pointer parameter; 1233 dcl code fixed bin (35); 1234 1235 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1236 1237 code = 0; 1238 call delete_from_buffer_save (lei_ptr, LEI.line_length - LEI.cursor_index + 1, FORWARD_KILL, code); 1239 1240 end kill_to_end_of_line; 1241 1242 twiddle_characters: 1243 procedure (lei_ptr, code); 1244 1245 dcl lei_ptr pointer parameter; 1246 dcl code fixed bin (35); 1247 1248 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1249 1250 dcl temp_char char (1); 1251 1252 code = 0; 1253 if LEI.cursor_index > 2 then do; 1254 temp_char = substr (LEI.input_buffer, LEI.cursor_index - 2, 1); 1255 substr (LEI.input_buffer, LEI.cursor_index - 2, 1) = substr (LEI.input_buffer, LEI.cursor_index - 1, 1); 1256 substr (LEI.input_buffer, LEI.cursor_index - 1, 1) = temp_char; 1257 end; 1258 else code = error_table_$action_not_performed; 1259 1260 end twiddle_characters; 1261 1262 terminate_input_line: 1263 procedure (lei_ptr, code); 1264 1265 dcl lei_ptr pointer parameter; 1266 dcl code fixed bin (35); 1267 1268 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1269 1270 code = 0; 1271 LEI.return_from_editor = "1"b; 1272 LEI.suppress_redisplay = "1"b; /* we will do redisplay ourselves, so the NL is hidden */ 1273 LEI.merge_next_kill = "0"b; 1274 LEI.cursor_index = LEI.line_length + 1; 1275 call redisplay_input_line (lei_ptr); /* to set cursor */ 1276 call insert_in_buffer (lei_ptr, NL, code); 1277 call get_to_next_line (); 1278 1279 end terminate_input_line; 1280 1281 clear_window: 1282 procedure (lei_ptr, code); 1283 1284 dcl lei_ptr pointer parameter; 1285 dcl code fixed bin (35); 1286 1287 code = 0; 1288 call clear_window_image (); 1289 get_line_entry_line = 1; 1290 get_line_entry_column = 1; 1291 1292 end clear_window; 1293 1294 quote_character: 1295 procedure (lei_ptr, code); 1296 1297 dcl lei_ptr pointer parameter; 1298 dcl code fixed bin (35); 1299 1300 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1301 1302 dcl temp_char_varying char (1) varying; 1303 dcl temp_index fixed bin; 1304 dcl repeat_count fixed bin; 1305 1306 code = 0; 1307 call window_$get_one_unechoed (iocb_ptr, temp_char_varying, "1"b, code); 1308 call async_or_error (code); 1309 if LEI.numarg_given then 1310 repeat_count = LEI.repetition_count; 1311 else repeat_count = 1; 1312 1313 do temp_index = 1 to repeat_count; 1314 call insert_in_buffer (lei_ptr, (temp_char_varying), code); 1315 end; 1316 1317 end quote_character; 1318 1319 yank_from_kill_ring: 1320 procedure (lei_ptr, code); 1321 1322 dcl lei_ptr pointer parameter; 1323 dcl code fixed bin (35); 1324 1325 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1326 1327 code = 0; 1328 call insert_in_buffer (lei_ptr, (killer.words), code); 1329 LEI.merge_next_kill = "0"b; 1330 1331 end yank_from_kill_ring; 1332 1333 process_input_escape: 1334 procedure (lei_ptr, code); 1335 1336 dcl lei_ptr pointer parameter; 1337 dcl code fixed bin (35); 1338 1339 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1340 1341 dcl input_char char (1) varying; 1342 dcl unprocessed_char char (1) varying; 1343 dcl count fixed bin (21); 1344 dcl escape_index fixed bin (21); 1345 dcl translation_idx fixed bin (21); 1346 dcl result fixed bin; 1347 1348 code = 0; 1349 1350 /* Remember where we started. */ 1351 escape_index = LEI.cursor_index; 1352 1353 /* Echo the \ immediately. */ 1354 call insert_in_buffer (lei_ptr, (attach_data.input_escape_char), code); 1355 if code ^= 0 then 1356 return; 1357 1358 call redisplay_input_line (lei_ptr); 1359 1360 call window_$get_one_unechoed (iocb_ptr, input_char, "1"b, code); 1361 call async_or_error (code); 1362 1363 /* Check for \nnn case. */ 1364 if (input_char >= "0") & (input_char <= "7") then do; 1365 result = fixed (input_char); /* calculate number */ 1366 call insert_in_buffer (lei_ptr, (input_char), code); 1367 if code ^= 0 then 1368 return; 1369 call redisplay_input_line (lei_ptr); 1370 1371 unprocessed_char = ""; 1372 do count = 2 to 3 while (length (unprocessed_char) = 0); 1373 call window_$get_one_unechoed (iocb_ptr, input_char, "1"b, code); 1374 call async_or_error (code); 1375 if (input_char >= "0") & (input_char <= "7") then do; 1376 result = result * 8; 1377 result = result + fixed (input_char); 1378 call insert_in_buffer (lei_ptr, (input_char), code); 1379 if code ^= 0 then 1380 return; 1381 1382 call redisplay_input_line (lei_ptr); 1383 end; /* got unwanted char, save it for later */ 1384 else unprocessed_char = input_char; 1385 end; 1386 1387 /* Get rid of "\nnn" and insert the char. */ 1388 count = LEI.cursor_index - escape_index; 1389 LEI.cursor_index = escape_index; 1390 call delete_from_buffer (lei_ptr, count, code); 1391 if code ^= 0 then 1392 return; 1393 call insert_in_buffer (lei_ptr, byte (result), code); 1394 if code ^= 0 then 1395 return; 1396 1397 /* See if recursive call is necessary. */ 1398 if length (unprocessed_char) > 0 then 1399 call process_break (lei_ptr, unprocessed_char); 1400 return; 1401 end; 1402 1403 if input_char = BELL then do; 1404 call window_$bell (iocb_ptr, code); 1405 call async_or_error (code); /* flush the \ */ 1406 LEI.cursor_index = escape_index; 1407 call delete_from_buffer (lei_ptr, 1, code); 1408 return; 1409 end; 1410 1411 if (input_char = attach_data.erase_char) | (input_char = attach_data.kill_char) 1412 | (input_char = attach_data.input_escape_char) then do; 1413 /* flush the \ */ 1414 LEI.cursor_index = escape_index; 1415 call delete_from_buffer (lei_ptr, 1, code); 1416 if code ^= 0 then 1417 return; /* add the char */ 1418 call insert_in_buffer (lei_ptr, (input_char), code); 1419 return; 1420 end; 1421 1422 /* If there are input escape sequences defined, use them. */ 1423 1424 if attach_data.special_ptr -> special_chars.input_escapes.len ^= 0 then do; 1425 translation_idx = index (attach_data.special_ptr -> special_chars.input_escapes.str, input_char); 1426 if translation_idx > 0 then do; /* flush \ */ 1427 LEI.cursor_index = escape_index; 1428 call delete_from_buffer (lei_ptr, 1, code); 1429 if code ^= 0 then 1430 return; 1431 call insert_in_buffer (lei_ptr, 1432 substr (attach_data.special_ptr -> special_chars.input_results.str, translation_idx, 1), code); 1433 return; 1434 end; 1435 end; 1436 1437 /* Otherwise result is \ */ 1438 call insert_in_buffer (lei_ptr, (input_char), code); 1439 1440 return; 1441 1442 end process_input_escape; 1443 1444 number_reader_0: 1445 procedure (lei_ptr, code); 1446 1447 dcl lei_ptr pointer parameter; 1448 dcl code fixed binary (35); 1449 1450 call number_reader_common (lei_ptr, 0, code); 1451 return; 1452 1453 end number_reader_0; 1454 1455 number_reader_1: 1456 procedure (lei_ptr, code); 1457 1458 dcl lei_ptr pointer parameter; 1459 dcl code fixed binary (35); 1460 1461 call number_reader_common (lei_ptr, 1, code); 1462 return; 1463 1464 end number_reader_1; 1465 1466 number_reader_2: 1467 procedure (lei_ptr, code); 1468 1469 dcl lei_ptr pointer parameter; 1470 dcl code fixed binary (35); 1471 1472 call number_reader_common (lei_ptr, 2, code); 1473 return; 1474 1475 end number_reader_2; 1476 1477 number_reader_3: 1478 procedure (lei_ptr, code); 1479 1480 dcl lei_ptr pointer parameter; 1481 dcl code fixed binary (35); 1482 1483 call number_reader_common (lei_ptr, 3, code); 1484 return; 1485 1486 end number_reader_3; 1487 1488 number_reader_4: 1489 procedure (lei_ptr, code); 1490 1491 dcl lei_ptr pointer parameter; 1492 dcl code fixed binary (35); 1493 1494 call number_reader_common (lei_ptr, 4, code); 1495 return; 1496 1497 end number_reader_4; 1498 1499 number_reader_5: 1500 procedure (lei_ptr, code); 1501 1502 dcl lei_ptr pointer parameter; 1503 dcl code fixed binary (35); 1504 1505 call number_reader_common (lei_ptr, 5, code); 1506 return; 1507 1508 end number_reader_5; 1509 1510 number_reader_6: 1511 procedure (lei_ptr, code); 1512 1513 dcl lei_ptr pointer parameter; 1514 dcl code fixed binary (35); 1515 1516 call number_reader_common (lei_ptr, 6, code); 1517 return; 1518 1519 end number_reader_6; 1520 1521 number_reader_7: 1522 procedure (lei_ptr, code); 1523 1524 dcl lei_ptr pointer parameter; 1525 dcl code fixed binary (35); 1526 1527 call number_reader_common (lei_ptr, 7, code); 1528 return; 1529 1530 end number_reader_7; 1531 1532 number_reader_8: 1533 procedure (lei_ptr, code); 1534 1535 dcl lei_ptr pointer parameter; 1536 dcl code fixed binary (35); 1537 1538 call number_reader_common (lei_ptr, 8, code); 1539 return; 1540 1541 end number_reader_8; 1542 1543 number_reader_9: 1544 procedure (lei_ptr, code); 1545 1546 dcl lei_ptr pointer parameter; 1547 dcl code fixed binary (35); 1548 1549 call number_reader_common (lei_ptr, 9, code); 1550 return; 1551 1552 end number_reader_9; 1553 1554 number_reader_common: 1555 procedure (lei_ptr, number, code); 1556 1557 dcl lei_ptr pointer parameter; 1558 dcl code fixed binary (35); 1559 dcl number fixed binary; 1560 1561 code = 0; 1562 if LEI.numarg_given then 1563 LEI.repetition_count = LEI.repetition_count * 10 + number; 1564 else LEI.repetition_count = number; 1565 1566 call read_numbers_then_dispatch (lei_ptr, "0"b /* not multiplier */, "0"b /* accummulate digits */, code); 1567 1568 return; 1569 1570 end number_reader_common; 1571 1572 multiplier: 1573 procedure (lei_ptr, code); 1574 1575 dcl lei_ptr pointer parameter; 1576 dcl code fixed binary (35); 1577 1578 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1579 1580 code = 0; 1581 if LEI.numarg_given then 1582 LEI.repetition_count = LEI.repetition_count * 4; 1583 else LEI.repetition_count = 4; 1584 1585 1586 call read_numbers_then_dispatch (lei_ptr, "1"b /* multiplier */, "1"b /* don't accummulate digits */, code); 1587 return; 1588 1589 end multiplier; 1590 1591 negative_number_reader: 1592 procedure (lei_ptr, code); 1593 1594 dcl lei_ptr pointer parameter; 1595 dcl code fixed binary (35); 1596 1597 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1598 1599 code = 0; 1600 LEI.repetition_count = -1; 1601 call read_numbers_then_dispatch (lei_ptr, "0"b /* not multiplier */, "1"b /* don't accumulate digits */, code); 1602 return; 1603 1604 end negative_number_reader; 1605 1606 read_numbers_then_dispatch: 1607 procedure (lei_ptr, multiplier_flag, replace_count_flag, code); 1608 1609 dcl lei_ptr pointer parameter; 1610 dcl code fixed binary (35); 1611 dcl multiplier_flag bit (1); 1612 dcl replace_count_flag bit (1); /* replace LEI.repetition_count if we get a digit, instead of adding to it */ 1613 1614 dcl next_char char (1) varying; 1615 1616 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1617 1618 LEI.numarg_given = "1"b; 1619 1620 get_more: 1621 call window_$get_one_unechoed (iocb_ptr, next_char, "1"b, code); 1622 call async_or_error (code); 1623 1624 if multiplier_flag & next_char = "-" then /* let the multiplier enter negative numeric args */ 1625 do; 1626 LEI.repetition_count = -4; 1627 replace_count_flag = "1"b; 1628 multiplier_flag = "0"b; 1629 goto get_more; 1630 end; 1631 1632 if next_char >= "0" & next_char <= "9" then do; 1633 if replace_count_flag then do; 1634 LEI.repetition_count = fixed (next_char) * sign (LEI.repetition_count); 1635 replace_count_flag = "0"b; 1636 end; 1637 else if LEI.repetition_count = 0 then 1638 LEI.repetition_count = fixed (next_char); 1639 /* handle leading zero */ 1640 else LEI.repetition_count = LEI.repetition_count * 10 + fixed (next_char) * sign (LEI.repetition_count); 1641 goto get_more; 1642 end; 1643 else do; 1644 call process_break (lei_ptr, (next_char)); 1645 return; 1646 end; 1647 1648 end read_numbers_then_dispatch; 1649 1650 backward_word: 1651 procedure (lei_ptr, code); 1652 1653 dcl lei_ptr pointer parameter; 1654 dcl code fixed bin (35); 1655 1656 code = 0; 1657 call move_backward_word (lei_ptr); 1658 1659 end backward_word; 1660 1661 forward_word: 1662 procedure (lei_ptr, code); 1663 1664 dcl lei_ptr pointer parameter; 1665 dcl code fixed bin (35); 1666 1667 code = 0; 1668 call move_forward_word (lei_ptr); 1669 1670 end forward_word; 1671 1672 forward_delete_word: 1673 procedure (lei_ptr, code); 1674 1675 dcl lei_ptr pointer parameter; 1676 dcl code fixed bin (35); 1677 1678 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1679 1680 dcl count fixed bin (21); 1681 dcl old_cursor fixed bin (21); 1682 1683 code = 0; 1684 old_cursor = LEI.cursor_index; 1685 call move_forward_word (lei_ptr); 1686 count = LEI.cursor_index - old_cursor; 1687 LEI.cursor_index = old_cursor; 1688 call delete_from_buffer_save (lei_ptr, count, FORWARD_KILL, code); 1689 return; 1690 1691 end forward_delete_word; 1692 1693 backward_delete_word: 1694 procedure (lei_ptr, code); 1695 1696 dcl lei_ptr pointer parameter; 1697 dcl code fixed bin (35); 1698 1699 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1700 1701 dcl count fixed bin (21); 1702 dcl old_cursor fixed bin (21); 1703 1704 code = 0; 1705 old_cursor = LEI.cursor_index; 1706 call move_backward_word (lei_ptr); 1707 count = old_cursor - LEI.cursor_index; 1708 call delete_from_buffer_save (lei_ptr, count, BACKWARD_KILL, code); 1709 1710 end backward_delete_word; 1711 1712 yank_previous_from_kill_ring: 1713 procedure (lei_ptr, code); 1714 1715 dcl lei_ptr pointer parameter; 1716 dcl code fixed bin (35); 1717 1718 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 1719 1720 code = 0; 1721 1722 /* Make sure that we don't subscript out of bounds */ 1723 if (LEI.cursor_index > length (killer.words)) /* Are we sitting after contents of top kill ring element? */ 1724 then if substr (LEI.input_buffer, LEI.cursor_index - length (killer.words), length (killer.words)) 1725 = killer.words then do; 1726 LEI.cursor_index = LEI.cursor_index - length (killer.words); 1727 call delete_from_buffer (lei_ptr, length (killer.words), code); 1728 if code ^= 0 then 1729 return; 1730 1731 call rotate_kill_ring (); 1732 call insert_in_buffer (lei_ptr, (killer.words), code); 1733 return; 1734 end; 1735 1736 code = error_table_$action_not_performed; 1737 return; 1738 1739 end yank_previous_from_kill_ring; 1740 1741 display_editor_documentation: 1742 procedure (lei_ptr, code); 1743 1744 dcl lei_ptr parameter pointer; 1745 dcl code fixed bin; 1746 1747 dcl ioa_ entry options (variable); 1748 1749 /*** This needs to be clevered up about key bindings */ 1750 1751 call ioa_ ( 1752 "^/^^A, ^^E, ^^F, ^^B, ^^D, DEL, ^a, ^^K, ^^Y, ^^L, ^^T, ESC-F, ESC-B,^/ESC-D, ESC-DEL, ESC-Y, ESC-C, ESC-L, ESC-U, ESC-T, ESC-?" 1753 , attach_data.kill_char); 1754 1755 /* Now do the awful things necessary to incorporate the output 1756* from the ioa_ call into the screen image and redisplay the 1757* input line in the correct location. */ 1758 1759 get_line_entry_line = attach_data.line; 1760 get_line_entry_column = attach_data.col; 1761 call initialize_window_image (); /* include stuff in redisplay */ 1762 return; 1763 1764 end display_editor_documentation; 1765 1766 lowercase_word: 1767 procedure (lei_ptr, code); 1768 1769 dcl lei_ptr parameter pointer; 1770 dcl code fixed binary (35); 1771 1772 dcl (start, end) fixed binary; 1773 dcl (i, repeat_count) fixed binary; 1774 dcl uppercase_flag bit (1); 1775 1776 dcl 1 LEI like line_editor_info based (lei_ptr); 1777 1778 uppercase_flag = "0"b; 1779 goto case_common; 1780 1781 uppercase_word: 1782 entry (lei_ptr, code); 1783 1784 uppercase_flag = "1"b; 1785 1786 case_common: 1787 code = 0; 1788 repeat_count = 1; 1789 1790 if LEI.numarg_given & LEI.repetition_count < 0 then do; 1791 /* no negative args for now */ 1792 call ring (); 1793 return; 1794 end; 1795 1796 if LEI.numarg_given then 1797 repeat_count = LEI.repetition_count; 1798 1799 do i = 1 to repeat_count; 1800 1801 call get_current_word_info (lei_ptr, start, end); 1802 1803 begin; 1804 dcl word char (end - start) defined (LEI.input_buffer) position (start); 1805 1806 if uppercase_flag then 1807 word = translate (word, uppercase, lowercase); 1808 else word = translate (word, lowercase, uppercase); 1809 1810 end; /* begin */ 1811 1812 call move_forward_word (lei_ptr); /* get to end of current word */ 1813 call move_forward_word (lei_ptr); /* get to end of next word for the repeat case */ 1814 1815 if LEI.cursor_index = end /* end of input buffer, the last forward_word did nothing */ 1816 then do; 1817 if LEI.numarg_given & i < repeat_count then 1818 call ring (); /* only ring if user gave a numaric arg which is too big */ 1819 return; 1820 end; 1821 1822 end; /* do loop */ 1823 1824 call move_backward_word (lei_ptr); /* undo the extra forward_word */ 1825 call move_backward_word (lei_ptr); /* must do twice */ 1826 call move_forward_word (lei_ptr); 1827 1828 return; 1829 1830 /* end uppercase_word; */ 1831 1832 end lowercase_word; 1833 1834 initial_capital: 1835 procedure (lei_ptr, code); 1836 1837 dcl lei_ptr parameter pointer; 1838 dcl code fixed binary (35); 1839 1840 dcl (start, end) fixed binary; 1841 dcl (i, repeat_count) fixed binary; 1842 1843 dcl 1 LEI like line_editor_info based (lei_ptr); 1844 1845 code = 0; 1846 repeat_count = 1; 1847 1848 if LEI.numarg_given & LEI.repetition_count < 0 then do; 1849 /* no negative args for now */ 1850 call ring (); 1851 return; 1852 end; 1853 1854 if LEI.numarg_given then 1855 repeat_count = LEI.repetition_count; 1856 1857 LEI.numarg_given = "0"b; /* fool lowercase_word */ 1858 1859 do i = 1 to repeat_count; 1860 1861 call lowercase_word (lei_ptr, code); 1862 if code ^= 0 then 1863 return; 1864 1865 call get_current_word_info (lei_ptr, start, end); 1866 1867 begin; 1868 dcl first_letter char (1) defined (LEI.input_buffer) position (start); 1869 first_letter = translate (first_letter, uppercase, lowercase); 1870 end; /* begin */ 1871 1872 call move_forward_word (lei_ptr); /* get to end of current word */ 1873 call move_forward_word (lei_ptr); /* get to end of next word for the repeat case */ 1874 1875 if LEI.cursor_index = end /* end of input buffer, the last forward_word did nothing */ 1876 then do; 1877 if repeat_count > 1 & i < repeat_count /* we bashed LEI.numarg_given above */ 1878 then call ring (); /* only ring if user gave a numaric arg which is too big */ 1879 return; 1880 end; 1881 1882 end; /* do loop */ 1883 1884 call move_backward_word (lei_ptr); /* undo the extra forward_word */ 1885 call move_backward_word (lei_ptr); /* must do twice */ 1886 call move_forward_word (lei_ptr); 1887 1888 return; 1889 1890 end initial_capital; 1891 1892 twiddle_words: 1893 procedure (lei_ptr, code); 1894 1895 dcl lei_ptr parameter pointer; 1896 dcl code fixed binary (35); 1897 1898 dcl (start, end) fixed binary; 1899 dcl (start2, end2) fixed binary; 1900 1901 dcl 1 LEI like line_editor_info based (lei_ptr); 1902 1903 code = 0; 1904 call get_current_word_info (lei_ptr, start, end); 1905 1906 if start = 1 then do; /* we are in the first word on the line, let's try to twiddle the first two 1907* words (if there are two of them) */ 1908 call move_forward_word (lei_ptr); 1909 call move_forward_word (lei_ptr); 1910 call get_current_word_info (lei_ptr, start, end); 1911 end; 1912 1913 begin; 1914 dcl word char (end - start); 1915 word = substr (LEI.input_buffer, LEI.cursor_index, end - start); 1916 1917 call delete_from_buffer (lei_ptr, end - start, code); 1918 if code ^= 0 then 1919 return; 1920 1921 call move_backward_word (lei_ptr); 1922 if code ^= 0 then 1923 return; 1924 1925 start2 = LEI.cursor_index; 1926 1927 call move_forward_word (lei_ptr); 1928 if code ^= 0 then 1929 return; 1930 1931 end2 = LEI.cursor_index; 1932 1933 begin; 1934 dcl word2 char (end2 - start2); 1935 word2 = substr (LEI.input_buffer, start2, end2 - start2); 1936 1937 LEI.cursor_index = start; 1938 call insert_in_buffer (lei_ptr, rtrim (word2), code); 1939 if code ^= 0 then 1940 return; 1941 end; 1942 1943 LEI.cursor_index = start2; 1944 call delete_from_buffer (lei_ptr, end2 - start2, code); 1945 if code ^= 0 then 1946 return; 1947 call insert_in_buffer (lei_ptr, rtrim (word), code); 1948 if code ^= 0 then 1949 return; 1950 1951 call move_forward_word (lei_ptr); 1952 1953 end; 1954 1955 return; 1956 1957 end twiddle_words; 1958 1959 get_current_word_info: 1960 procedure (lei_ptr, start, end); 1961 1962 /* return the start and end postions and the "current" word. Do 1963* something reasonable if we are in the middle of words */ 1964 1965 /* leaves line_editor_info.cursor_index set to the start of the word */ 1966 1967 dcl (start, end) fixed binary; 1968 1969 dcl lei_ptr parameter pointer; 1970 dcl 1 LEI like line_editor_info based (lei_ptr); 1971 1972 start = LEI.cursor_index; 1973 call move_forward_word (lei_ptr); 1974 end = LEI.cursor_index; 1975 1976 call move_backward_word (lei_ptr); 1977 1978 if LEI.cursor_index <= start then do; /* start is in the middle of the word */ 1979 start = LEI.cursor_index; 1980 call move_forward_word (lei_ptr); 1981 end = LEI.cursor_index; 1982 LEI.cursor_index = start; 1983 end; 1984 else do; /* we were at the end of a word, the foward word has screwed us */ 1985 call move_backward_word (lei_ptr); 1986 start = LEI.cursor_index; 1987 call move_forward_word (lei_ptr); 1988 end = LEI.cursor_index; 1989 LEI.cursor_index = start; 1990 end; 1991 1992 end get_current_word_info; 1993 1994 /* Routine to clear the internal window image. Called from ^L, etc. */ 1995 clear_window_image: 1996 procedure (); 1997 1998 window_image = ""; 1999 WINDOW_LINE_USED = "0"b; 2000 2001 return; 2002 2003 end clear_window_image; 2004 2005 /* Utilities for manipulating words within the buffer. */ 2006 2007 move_forward_word: 2008 procedure (lei_ptr); 2009 2010 dcl lei_ptr pointer parameter; 2011 2012 dcl token_start_index fixed bin; 2013 dcl token_end_index fixed bin; 2014 2015 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 2016 2017 begin; 2018 2019 dcl buffer_chunk char (LEI.line_length - LEI.cursor_index + 1) defined (LEI.input_buffer) 2020 position (LEI.cursor_index); 2021 2022 /* First skip to beginning of word. */ 2023 2024 token_start_index = search (buffer_chunk, valid_token_characters); 2025 2026 if token_start_index = 0 then 2027 return; /* No more words. */ 2028 2029 /* Now skip over token itself. */ 2030 token_end_index = verify (substr (buffer_chunk, token_start_index), valid_token_characters); 2031 2032 if token_end_index = 0 /* word at end of line */ 2033 then LEI.cursor_index = LEI.line_length + 1; 2034 else LEI.cursor_index = LEI.cursor_index + token_start_index + token_end_index - 2; 2035 2036 return; 2037 2038 end; 2039 end move_forward_word; 2040 2041 move_backward_word: 2042 procedure (lei_ptr); 2043 2044 dcl lei_ptr pointer parameter; 2045 2046 dcl token_start_index fixed bin; 2047 dcl token_end_index fixed bin; 2048 2049 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 2050 2051 begin; 2052 2053 dcl buffer_chunk char (LEI.cursor_index - 1) defined (LEI.input_buffer) position (1); 2054 2055 /* First skip to end of previous word. */ 2056 2057 token_start_index = search (reverse (buffer_chunk), valid_token_characters); 2058 2059 if token_start_index = 0 then 2060 return; /* No more words. */ 2061 2062 /* Now skip over token itself. */ 2063 token_end_index = verify (substr (reverse (buffer_chunk), token_start_index), valid_token_characters); 2064 2065 if token_end_index = 0 /* word at beginning of line */ 2066 then LEI.cursor_index = 1; 2067 else LEI.cursor_index = LEI.cursor_index - token_start_index - token_end_index + 2; 2068 2069 return; 2070 end; 2071 end move_backward_word; 2072 2073 /* Utility routines to manage the editor's input buffer. */ 2074 2075 insert_in_buffer: 2076 procedure (lei_ptr, text, code); 2077 2078 dcl lei_ptr pointer parameter; 2079 dcl text char (*) parameter; 2080 dcl code fixed bin (35) parameter; 2081 2082 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 2083 2084 dcl copy_count fixed bin; 2085 2086 code = 0; 2087 2088 /* If there isn't enough room in the buffer for the entire string, 2089* don't insert any of it. */ 2090 2091 if length (text) > (length (LEI.input_buffer) - LEI.line_length) then 2092 code = error_table_$action_not_performed; 2093 else do; /* Open up space for the text and insert it. */ 2094 copy_count = LEI.line_length - LEI.cursor_index + 1; 2095 /* must use copy builtin to avoid MLR screw. */ 2096 substr (LEI.input_buffer, LEI.cursor_index + length (text), copy_count) = 2097 copy (substr (LEI.input_buffer, LEI.cursor_index, copy_count), 1); 2098 substr (LEI.input_buffer, LEI.cursor_index, length (text)) = text; 2099 LEI.line_length = LEI.line_length + length (text); 2100 LEI.cursor_index = LEI.cursor_index + length (text); 2101 end; 2102 return; 2103 2104 end insert_in_buffer; 2105 2106 delete_from_buffer: 2107 procedure (lei_ptr, delete_count, code); 2108 2109 dcl lei_ptr pointer parameter; 2110 dcl delete_count fixed bin (21) parameter; 2111 dcl kill_direction bit (1) aligned parameter; 2112 dcl code fixed bin (35) parameter; 2113 2114 dcl 1 LEI aligned like line_editor_info based (lei_ptr); 2115 2116 dcl save_on_kill_ring bit (1); 2117 dcl move_count fixed bin; 2118 2119 save_on_kill_ring = "0"b; 2120 goto common_delete; 2121 2122 delete_from_buffer_save: 2123 entry (lei_ptr, delete_count, kill_direction, code); 2124 2125 save_on_kill_ring = "1"b; 2126 2127 common_delete: 2128 code = 0; 2129 2130 /* If there aren't enough caracters in the buffer, do nothing. */ 2131 2132 if (delete_count + LEI.cursor_index - 1) > LEI.line_length then 2133 code = error_table_$action_not_performed; 2134 else do; 2135 if save_on_kill_ring then 2136 call add_to_kill_ring (lei_ptr, LEI.cursor_index, delete_count, kill_direction); 2137 2138 move_count = LEI.line_length - LEI.cursor_index - delete_count + 1; 2139 substr (LEI.input_buffer, LEI.cursor_index, move_count) = 2140 substr (LEI.input_buffer, LEI.cursor_index + delete_count, move_count); 2141 LEI.line_length = LEI.line_length - delete_count; 2142 end; 2143 return; 2144 2145 end delete_from_buffer; 2146 2147 /* Routines for managing the window image and performing redsiplay. 2148* 2149* The basic idea is that most changes will be reflected through the 2150* regular redisplay process. However, some editor requests deal with the 2151* screen image instead of the editor buffer, so we need routines to modify 2152* the image directly. */ 2153 2154 /* Routine to add to the window image text that has already been echoed to 2155* the screen by a call to window_$get_echoed_chars. */ 2156 2157 add_to_window_image: 2158 procedure (text, line, column); 2159 2160 dcl text char (*) parameter; 2161 dcl line fixed bin parameter; 2162 dcl column fixed bin parameter; 2163 2164 2165 substr (window_image (line), column, length (text)) = text; 2166 WINDOW_LINE_USED (line) = "1"b; 2167 return; 2168 end add_to_window_image; 2169 2170 /* Main redisplay routine. Performs output conversions on all characters in 2171* the input buffer, and then splits up the converted string into lines 2172* as wide as the screen and writes them into the window image. We rely on 2173* window_display_ to perform redisplay optimizations. */ 2174 2175 redisplay_input_line: 2176 procedure (lei_ptr); 2177 2178 dcl lei_ptr ptr parameter; 2179 2180 dcl converted_cursor fixed bin (21); 2181 dcl converted_length fixed bin (21); 2182 dcl last_character_line fixed bin; 2183 dcl last_character_column fixed bin; 2184 dcl cursor_line fixed bin; 2185 dcl cursor_column fixed bin; 2186 dcl line fixed bin; 2187 dcl window_width fixed bin; 2188 dcl processed fixed bin (21); 2189 dcl line_offset fixed bin; 2190 2191 dcl input_buffer char (LEI.line_length) defined (LEI.input_buffer) position (1); 2192 2193 dcl window_display_ entry (ptr, (*) char (*), fixed bin (35)); 2194 2195 if attach_data.suppress_echo then do; 2196 redisplay_buffer = ""; 2197 converted_length = length (input_buffer); 2198 converted_cursor = LEI.cursor_index; 2199 end; 2200 2201 else call perform_output_conversions (input_buffer, 1, redisplay_buffer, converted_length, LEI.cursor_index, 2202 converted_cursor); 2203 2204 window_width = attach_data.current.columns; 2205 processed = 0; 2206 2207 /* First clear old input redisplay. */ 2208 substr (window_image (get_line_entry_line), get_line_entry_column) = ""; 2209 WINDOW_LINE_USED (get_line_entry_line) = "0"b; 2210 2211 do line = (get_line_entry_line + 1) to attach_data.current.rows, 1 to (get_line_entry_line - 1); 2212 if WINDOW_LINE_USED (line) then do; 2213 window_image (line) = ""; 2214 WINDOW_LINE_USED (line) = "0"b; 2215 end; 2216 end; 2217 2218 /* Then fill in first line. */ 2219 2220 line = get_line_entry_line; /* Take one window line or as much as there is. */ 2221 processed = min (converted_length, window_width - get_line_entry_column + 1); 2222 substr (window_image (line), get_line_entry_column) = substr (redisplay_buffer, 1, processed); 2223 WINDOW_LINE_USED (line) = "1"b; 2224 last_character_line = line; 2225 last_character_column = get_line_entry_column + processed - 1; 2226 2227 /* Now loop through filling in entire screen lines. */ 2228 2229 window_width = window_width - length (CONTINUATION_CHARS); 2230 2231 do while ((converted_length - processed) > window_width); 2232 line = line + 1; 2233 if line > attach_data.current.rows then 2234 if attach_data.more_mode = MORE_MODE_SCROLL then do; 2235 call scroll_window_image; 2236 line = attach_data.current.rows; 2237 end; 2238 else line = 1; 2239 2240 window_image (line) = CONTINUATION_CHARS || substr (redisplay_buffer, processed + 1, window_width); 2241 WINDOW_LINE_USED (line) = "1"b; 2242 processed = processed + window_width; 2243 last_character_line = line; 2244 last_character_column = attach_data.current.columns; 2245 end; 2246 2247 /* Now finish up with last line. */ 2248 2249 if (converted_length > processed) then do; 2250 line = line + 1; 2251 if line > attach_data.current.rows then 2252 if attach_data.more_mode = MORE_MODE_SCROLL then do; 2253 call scroll_window_image; 2254 line = attach_data.current.rows; 2255 end; 2256 else line = 1; 2257 2258 window_image (line) = 2259 CONTINUATION_CHARS || substr (redisplay_buffer, processed + 1, converted_length - processed); 2260 WINDOW_LINE_USED (line) = "1"b; 2261 last_character_line = line; 2262 last_character_column = (converted_length - processed) + length (CONTINUATION_CHARS); 2263 end; 2264 2265 call window_display_ (iocb_ptr, window_image, code); 2266 call async_or_error (code); 2267 2268 if (LEI.cursor_index > LEI.line_length) then do; /* We know right where to put cursor. */ 2269 cursor_line = last_character_line; 2270 cursor_column = last_character_column + 1; 2271 end; 2272 else do; /* We need to calculate an arbitrary cursor position. */ 2273 /* fudge here to get phantom col to work right. */ 2274 line_offset = 2275 divide (converted_cursor + (get_line_entry_column - 1) - length (CONTINUATION_CHARS) - 1, 2276 window_width, 17, 0); 2277 line_offset = max (0, line_offset); 2278 2279 cursor_line = get_line_entry_line + line_offset; 2280 2281 /* Now see if we went over bottom window boundary. */ 2282 if cursor_line > attach_data.current.rows then 2283 cursor_line = cursor_line - attach_data.current.rows; 2284 2285 /* Compute the cursor column, allowing for continuation chars. */ 2286 cursor_column = 2287 mod (converted_cursor + (get_line_entry_column - 1) + (line_offset * length (CONTINUATION_CHARS)), 2288 attach_data.current.columns); 2289 2290 if cursor_column = 0 then 2291 cursor_column = attach_data.current.columns; 2292 end; 2293 2294 call window_$position_cursor (iocb_ptr, cursor_line, cursor_column, code); 2295 call async_or_error (code); 2296 return; 2297 2298 scroll_window_image: 2299 procedure; 2300 2301 dcl line fixed bin; 2302 2303 do line = 1 to (attach_data.current.rows - 1); 2304 window_image (line) = window_image (line + 1); 2305 WINDOW_LINE_USED (line) = WINDOW_LINE_USED (line + 1); 2306 end; 2307 2308 call window_$scroll_region (iocb_ptr, 1, attach_data.current.rows, -1, code); 2309 call async_or_error (code); 2310 2311 /* Update our entry line for redisplay. If the first line of input 2312* display scrolls off the top, who knows what to do? */ 2313 if (get_line_entry_line > 1) then 2314 get_line_entry_line = get_line_entry_line - 1; 2315 else get_line_entry_column = 1; /* have lost 1st line */ 2316 2317 return; 2318 end scroll_window_image; 2319 2320 end redisplay_input_line; 2321 2322 /* Utility to perform actual output conversions. 2323* 2324* Called by input side to convert the entire input buffer. Any character in 2325* it must be ordinary or have been explicitly quoted to get there. Returns 2326* the index in the output string of the char that the cursor points at in the 2327* input string. */ 2328 2329 perform_output_conversions: 2330 procedure (input_string, start_index, output_string, chars_returned, cursor_index, converted_cursor_index); 2331 2332 2333 dcl input_string char (*) parameter; 2334 dcl start_index fixed bin (21) parameter; 2335 dcl output_string char (*) parameter; 2336 dcl chars_returned fixed bin (21) parameter; 2337 dcl cursor_index fixed bin (21) parameter; 2338 dcl converted_cursor_index fixed bin (21) parameter; 2339 2340 dcl char_index fixed bin (21); 2341 dcl char_type fixed bin; 2342 dcl start fixed bin (21); 2343 dcl chars_seen fixed bin (21); 2344 dcl converted_length fixed bin; 2345 2346 converted_cursor_index = 0; 2347 output_string = ""; 2348 chars_returned = 0; 2349 2350 start = start_index; 2351 2352 do while (start <= length (input_string)); 2353 2354 /* define a substring of input_string containing the chars 2355* that haven't been processed yet. */ 2356 begin; 2357 dcl new_input char (length (input_string) - start + 1) defined (input_string) position (start); 2358 2359 call scan_for_interesting_char (new_input, 1, char_index, char_type); 2360 2361 /* Find the index in the output string of the cursor 2362* specified in the input string. */ 2363 2364 if char_index = 0 then 2365 chars_seen = length (input_string) + 1; 2366 else chars_seen = start + char_index - 1; 2367 2368 /* Find out if cursor_index is in chunk we just processed */ 2369 if (converted_cursor_index = 0) & (cursor_index >= start) & (cursor_index <= chars_seen) then 2370 converted_cursor_index = chars_returned + cursor_index - start + 1; 2371 2372 if char_index = 0 /* no more odd chars */ 2373 then do; 2374 substr (output_string, chars_returned + 1) = new_input; 2375 chars_returned = chars_returned + length (new_input); 2376 start = length (input_string) + 1; 2377 end; 2378 2379 else do; 2380 substr (output_string, chars_returned + 1) = substr (new_input, 1, char_index - 1); 2381 chars_returned = chars_returned + char_index - 1; 2382 2383 /* Make sure no wierd chars get through. */ 2384 if (char_type = OUTPUT_CONVERT_RRS) | (char_type = OUTPUT_CONVERT_BRS) then 2385 char_type = OUTPUT_CONVERT_OCTAL; 2386 2387 /* Output convert the interesting char. */ 2388 substr (output_string, chars_returned + 1) = 2389 convert_char (substr (new_input, char_index, 1), char_type, chars_returned + 1, 2390 converted_length); 2391 chars_returned = chars_returned + converted_length; 2392 start = start + char_index; 2393 end; 2394 2395 end; /* begin block */ 2396 end; /* do while */ 2397 2398 /* The cursor_index should never be zero, even for a zero length 2399* input buffer. */ 2400 if (converted_cursor_index = 0) then 2401 converted_cursor_index = chars_returned + 1; 2402 2403 return; 2404 2405 end perform_output_conversions; 2406 2407 scan_for_interesting_char: 2408 procedure (text, start_index, char_index, char_type); 2409 2410 dcl text char (*) parameter; 2411 dcl start_index fixed bin (21) parameter; 2412 dcl char_index fixed bin (21) parameter; 2413 dcl char_type fixed bin parameter; 2414 2415 dcl temp_char char (1); 2416 2417 dcl find_char_$translate_first_in_table 2418 entry (char(*), char(512) aligned, fixed bin(21)) returns (char(1)); 2419 2420 dcl defined_text char (length (text) - start_index + 1) defined (text) position (start_index); 2421 2422 temp_char = find_char_$translate_first_in_table (defined_text, attach_data.conversion_tct_table, char_index); 2423 2424 char_type = rank (temp_char); 2425 2426 return; 2427 2428 output_convert_one_character: 2429 entry (char) returns (fixed bin); 2430 2431 dcl char char (1) parameter; 2432 2433 temp_char = substr (attach_data.conversion_tct_table, rank (char) + 1, 1); 2434 return (rank (temp_char)); 2435 2436 end scan_for_interesting_char; 2437 2438 convert_char: 2439 procedure (char, char_type, current_hpos, converted_length) returns (char (32) varying); 2440 2441 dcl char char (1) parameter; 2442 dcl char_type fixed bin parameter; 2443 dcl current_hpos fixed bin parameter; 2444 dcl converted_length fixed bin parameter; 2445 2446 2447 converted_length = 0; 2448 2449 if char_type = OUTPUT_CONVERT_HT then do; 2450 converted_length = 10 - mod (current_hpos - 1, 10); 2451 return (substr (TEN_SPACES, 1, converted_length)); 2452 end; 2453 2454 if (char_type = OUTPUT_CONVERT_OCTAL) | (char_type = OUTPUT_CONVERT_CR) | (char_type = OUTPUT_CONVERT_BS) 2455 then do; 2456 2457 /* quickest, dirtiest octal converter we could think of */ 2458 2459 convert_octal_rep: 2460 begin; 2461 2462 dcl octal_rep char (4); 2463 2464 dcl 1 decomp unaligned, 2465 2 digit_1 fixed bin (3) unsigned, 2466 2 digit_2 fixed bin (3) unsigned, 2467 2 digit_3 fixed bin (3) unsigned; 2468 2469 dcl digit_table (0:7) char (1) static options (constant) init ("0", "1", "2", "3", "4", "5", "6", "7"); 2470 2471 if attach_data.flags.edited then return(""); /* punt if we are in edited mode */ 2472 2473 unspec (decomp) = unspec (char); 2474 2475 substr (octal_rep, 1, 1) = attach_data.input_escape_char; 2476 2477 substr (octal_rep, 2, 1) = digit_table (decomp.digit_1); 2478 substr (octal_rep, 3, 1) = digit_table (decomp.digit_2); 2479 substr (octal_rep, 4, 1) = digit_table (decomp.digit_3); 2480 2481 converted_length = 4; 2482 return (octal_rep); 2483 end; /* begin */ 2484 end; /* do */ 2485 2486 if char_type = OUTPUT_CONVERT_ORDINARY then do; 2487 converted_length = 1; 2488 return (char); 2489 end; 2490 2491 if (char_type = OUTPUT_CONVERT_RRS) then 2492 return ( 2493 convert_special_sequence (attach_data.special_ptr -> special_chars.red_ribbon_shift, converted_length) 2494 ); 2495 2496 if (char_type = OUTPUT_CONVERT_BRS) then 2497 return ( 2498 convert_special_sequence (attach_data.special_ptr -> special_chars.black_ribbon_shift, 2499 converted_length)); 2500 2501 if (char_type >= OUTPUT_CONVERT_FIRST_SPECIAL) /* assume that the special translations always consist 2502* of regular printing characters. */ 2503 then if ^attach_data.flags.edited 2504 then return ( 2505 convert_special_sequence (attach_data.special_ptr 2506 -> special_chars.not_edited_escapes (char_type - OUTPUT_CONVERT_FIRST_SPECIAL + 1), converted_length)); 2507 else return ( 2508 convert_special_sequence (attach_data.special_ptr 2509 -> special_chars.edited_escapes (char_type - OUTPUT_CONVERT_FIRST_SPECIAL + 1), converted_length)); 2510 2511 /* Otherwise, assume octal coversion. */ 2512 2513 goto convert_octal_rep; 2514 2515 convert_special_sequence: 2516 procedure (c_chars_struc, special_length) returns (char (15) varying); 2517 2518 dcl 1 c_chars_struc aligned like c_chars parameter; 2519 dcl special_length fixed bin; 2520 2521 dcl special_string char (c_chars_struc.count) defined (c_chars_struc.chars) position (1); 2522 2523 special_length = length (special_string); 2524 return (special_string); 2525 2526 end convert_special_sequence; 2527 2528 end convert_char; 2529 2530 get_to_next_line: 2531 procedure; 2532 2533 /* Used on put_chars side to get to next line. */ 2534 2535 attach_data.lines_written_since_read = attach_data.lines_written_since_read + 1; 2536 2537 if attach_data.line < attach_data.current.rows then do; 2538 call window_$position_cursor (iocb_ptr, attach_data.line + 1, 1, code); 2539 /* simple case */ 2540 call async_or_error (code); 2541 call clear_to_end_of_line; /* comes out neater this way */ 2542 end; 2543 2544 else do; 2545 2546 goto more_type (attach_data.more_mode); 2547 2548 more_type (1): /* MORE_MODE_SCROLL */ 2549 call window_$scroll_region (iocb_ptr, 1, attach_data.current.rows, -1, code); 2550 if code = video_et_$capability_lacking /* this shouldn't happen, but just in case */ 2551 then goto more_type (MORE_MODE_WRAP); 2552 call async_or_error (code); 2553 call window_$position_cursor (iocb_ptr, attach_data.line, 1, code); 2554 call async_or_error (code); 2555 go to moved; 2556 2557 more_type (2): /* MORE_MODE_CLEAR */ 2558 call window_$clear_window (iocb_ptr, code); 2559 call async_or_error (code); 2560 go to moved; 2561 2562 more_type (3): /* MORE_MODE_WRAP */ 2563 more_type (4): /* MORE_MODE_FOLD */ 2564 call window_$position_cursor (iocb_ptr, 1, 1, code); 2565 call async_or_error (code); 2566 call clear_to_end_of_line; 2567 2568 moved: 2569 end; 2570 end get_to_next_line; 2571 2572 /* Routine to actually do output conversion on text and send it on to 2573* window_. */ 2574 2575 put_out_chars: 2576 procedure (text); 2577 2578 dcl text char (*) parameter; 2579 2580 dcl text_ptr pointer; 2581 dcl line_left fixed bin; 2582 dcl ordinary_count fixed bin (21); 2583 dcl temp_count fixed bin (21); 2584 dcl interesting_char_index fixed bin (21); 2585 dcl interesting_char_type fixed bin; 2586 dcl interesting_char char (1); 2587 dcl char_rep char (32) varying; 2588 dcl char_temp char (32); 2589 dcl char_rep_length fixed bin; 2590 dcl (saved_line, saved_column) 2591 fixed bin; 2592 2593 2594 text_ptr = addr (text); 2595 PROCESSED_SO_FAR = 0; /* kept globally for async restart */ 2596 line_left = attach_data.current.columns - attach_data.col + 1; 2597 2598 do while (PROCESSED_SO_FAR < length (text)); 2599 2600 /* search for the first non-vanilla character */ 2601 call scan_for_interesting_char (text, PROCESSED_SO_FAR + 1, interesting_char_index, interesting_char_type); 2602 2603 if interesting_char_index = 0 then 2604 ordinary_count = length (text) - PROCESSED_SO_FAR; 2605 else do; 2606 ordinary_count = (interesting_char_index - 1); 2607 interesting_char_index = interesting_char_index + PROCESSED_SO_FAR; 2608 end; 2609 2610 /* Process ordinary characters. */ 2611 2612 /* If this is the end of a line, rtrim the text. */ 2613 if (interesting_char_type = OUTPUT_CONVERT_NEWLINE) then do; 2614 temp_count = length (rtrim (substr (text, PROCESSED_SO_FAR + 1, ordinary_count))); 2615 2616 call write_with_continuation (text_ptr, temp_count, line_left); 2617 end; 2618 2619 else call write_with_continuation (text_ptr, ordinary_count, line_left); 2620 2621 PROCESSED_SO_FAR = PROCESSED_SO_FAR + ordinary_count; 2622 text_ptr = addcharno (text_ptr, ordinary_count); 2623 2624 /* now handle the special character, if any */ 2625 if interesting_char_index ^= 0 then do; 2626 PROCESSED_SO_FAR = PROCESSED_SO_FAR + 1; 2627 text_ptr = addcharno (text_ptr, 1); 2628 2629 interesting_char = substr (text, interesting_char_index, 1); 2630 char_rep = 2631 convert_char (interesting_char, interesting_char_type, 2632 attach_data.current.columns - line_left + 1, char_rep_length); 2633 2634 if (interesting_char_type = OUTPUT_CONVERT_NEWLINE) then do; 2635 call get_to_next_line; 2636 line_left = attach_data.current.columns; 2637 end; 2638 2639 /* Eliminate CR from the output stream for now. */ 2640 else if (interesting_char_type = OUTPUT_CONVERT_CR) then 2641 ; 2642 2643 /* Special case BELL to beep. */ 2644 else if (interesting_char = BELL) then 2645 call ring (); 2646 2647 /* Handle FF in vertsp mode. */ 2648 else if ((interesting_char_type = OUTPUT_CONVERT_FF) | (interesting_char_type = OUTPUT_CONVERT_VT)) 2649 & attach_data.vertsp then do; /* What does vertsp mean in video? For now, 2650* cause a more break. */ 2651 if (attach_data.more_mode = MORE_MODE_SCROLL) | (attach_data.more_mode = MORE_MODE_FOLD) then do; 2652 call get_to_next_line (); 2653 attach_data.lines_written_since_read = attach_data.current.rows + 1; 2654 end; 2655 else do; /* WRAP or CLEAR */ 2656 call window_$clear_to_end_of_window (iocb_ptr, code); 2657 call async_or_error (code); 2658 call window_$position_cursor (iocb_ptr, attach_data.current.rows, 1, code); 2659 call async_or_error (code); 2660 end; 2661 end; 2662 2663 /* Handle red/black shifts. */ 2664 else if (interesting_char_type = OUTPUT_CONVERT_RRS) | (interesting_char_type = OUTPUT_CONVERT_BRS) 2665 then if attach_data.red then do; 2666 saved_line = attach_data.line; 2667 saved_column = attach_data.col; 2668 call raw_write ((char_rep)); 2669 call window_$position_cursor (iocb_ptr, saved_line, saved_column, code); 2670 call async_or_error (code); 2671 end; 2672 else ; 2673 2674 /* Assume that anything else has been handled by 2675* convert_char and can be printed. */ 2676 else do; 2677 char_temp = char_rep; 2678 call write_with_continuation (addr (char_temp), length (char_rep), line_left); 2679 end; 2680 2681 end; /* if interesting chars */ 2682 end; /* main do loop */ 2683 2684 2685 write_with_continuation: 2686 procedure (text_ptr, text_length, line_left); 2687 2688 dcl text_ptr pointer parameter; 2689 dcl text_length fixed bin (21) parameter; 2690 dcl line_left fixed bin parameter; 2691 2692 dcl chars_left_to_write fixed bin; 2693 dcl start_idx fixed bin (21); 2694 dcl start_ptr pointer; 2695 2696 start_idx = 1; 2697 start_ptr = text_ptr; 2698 2699 /* Write out chunks as long as the screen is wide. */ 2700 do while ((text_length - start_idx + 1) > line_left); 2701 call write_string (start_ptr, line_left); 2702 call get_to_next_line; 2703 call write_string (addr (CONTINUATION_CHARS), length (CONTINUATION_CHARS)); 2704 start_idx = start_idx + line_left; 2705 start_ptr = addcharno (start_ptr, line_left); 2706 line_left = attach_data.current.columns - length (CONTINUATION_CHARS); 2707 end; 2708 2709 /* Now write out the remaining short line. */ 2710 chars_left_to_write = text_length - start_idx + 1; 2711 call write_string (start_ptr, chars_left_to_write); 2712 line_left = line_left - chars_left_to_write; 2713 return; 2714 2715 end write_with_continuation; 2716 2717 write_string: 2718 procedure (text_ptr, text_length); 2719 2720 dcl text_ptr pointer parameter; 2721 dcl text_length fixed bin parameter; 2722 2723 dcl text char (text_length) based (text_ptr); 2724 2725 call check_more (); 2726 call window_$overwrite_text (iocb_ptr, text, code); 2727 call async_or_error (code); 2728 2729 return; 2730 end write_string; 2731 2732 end put_out_chars; 2733 2734 /* ***** Kill Ring Management ***** 2735* 2736* Contiguous killed text is saved in a single buffer. We try to 2737* look like Emacs. Killed buffers are linked in a ring. The top 2738* item on the ring is given by attach_data.top_killer. The ring 2739* rotates towards killer.next. A new item is added before the top, 2740* and the old top is the new second. Killers are either in the 2741* ring or on the free list (attach_data.army). If the last request 2742* was also a kill, we add the new killed stuff to the existing kill 2743* ring element. 2744**/ 2745 2746 add_to_kill_ring: 2747 procedure (lei_ptr, start_idx, char_count, kill_direction); 2748 2749 dcl lei_ptr pointer parameter; 2750 dcl start_idx fixed bin (21) parameter; 2751 dcl char_count fixed bin (21) parameter; 2752 dcl kill_direction bit (1) aligned parameter; 2753 2754 dcl killer_count fixed bin; 2755 dcl current_killer pointer; 2756 2757 dcl KILL_RING_SIZE fixed bin static options (constant) init (10); 2758 2759 dcl text_to_add char (char_count) defined (LEI.input_buffer) position (start_idx); 2760 2761 dcl 1 LEI like line_editor_info based (lei_ptr); 2762 2763 current_killer = attach_data.top_killer; 2764 2765 /* If what we are adding is already in the ring, and we are 2766* not merging this kill, punt. */ 2767 2768 if ^LEI.old_merge_next_kill & (text_to_add = killer.words) then 2769 return; 2770 2771 /* The size of the kill ring is managed here. The length should 2772* be kept somewhere so we don't have to count each time. */ 2773 2774 current_killer = current_killer -> killer.next; 2775 2776 do killer_count = 1 by 1 while (current_killer ^= attach_data.top_killer); 2777 current_killer = current_killer -> killer.next; 2778 end; 2779 2780 if killer_count > KILL_RING_SIZE then do; 2781 current_killer = current_killer -> killer.prev; 2782 call free_killer (current_killer); 2783 end; 2784 2785 /* now go on with the actual killing */ 2786 2787 /* If we aren't merging this kill with another and the top kill 2788* ring element is not empty, allocate a new one. */ 2789 if ^LEI.old_merge_next_kill & (killer.words ^= "") then 2790 call insert_new_kill_ring_element (); 2791 2792 LEI.merge_next_kill = "1"b; 2793 LEI.last_kill_direction = kill_direction; 2794 2795 do while (length (text_to_add) + length (killer.words) > maxlength (killer.words)); 2796 call expand_kill_ring_element (); 2797 end; 2798 2799 if kill_direction = FORWARD_KILL then 2800 killer.words = killer.words || text_to_add; 2801 else killer.words = text_to_add || killer.words; 2802 2803 return; 2804 2805 end add_to_kill_ring; 2806 2807 rotate_kill_ring: 2808 procedure (); 2809 2810 attach_data.top_killer = killer.next; 2811 return; 2812 2813 end rotate_kill_ring; 2814 2815 /* The following are utilities used by above kill ring routines. */ 2816 2817 insert_new_kill_ring_element: 2818 procedure (); 2819 2820 dcl k ptr; 2821 2822 k = attach_data.top_killer; /* old top */ 2823 2824 attach_data.top_killer = get_free_killer (); /* from free list */ 2825 if attach_data.top_killer = null () /* were none */ 2826 then attach_data.top_killer = alloc_killer (); 2827 2828 killer.next = k; /* old top */ 2829 killer.prev = k -> killer.prev; 2830 k -> killer.prev = attach_data.top_killer; 2831 killer.prev -> killer.next = attach_data.top_killer; 2832 2833 killer.words = ""; 2834 return; 2835 end insert_new_kill_ring_element; 2836 2837 get_free_killer: 2838 procedure returns (ptr); 2839 2840 declare t ptr; 2841 2842 /* the free list (army) is only forward threaded through 2843* killer.next */ 2844 2845 t = attach_data.army; /* first on free list */ 2846 if t ^= null () then 2847 attach_data.army = t -> killer.next; 2848 2849 return (t); 2850 end get_free_killer; 2851 2852 alloc_killer: 2853 procedure returns (pointer); 2854 2855 dcl new pointer; 2856 2857 killer_alloc_size = killer_initial_alloc_size; 2858 allocate killer in (attach_data_area) set (new); 2859 new -> killer.next, new -> killer.prev = null (); 2860 new -> killer.words = ""; 2861 return (new); 2862 end alloc_killer; 2863 2864 free_killer: 2865 procedure (killer_ptr); 2866 2867 declare killer_ptr pointer; 2868 2869 /* adds a killer to the free list, unchaining it from the ring */ 2870 2871 killer_ptr -> killer.prev -> killer.next = killer_ptr -> killer.next; 2872 killer_ptr -> killer.next -> killer.prev = killer_ptr -> killer.prev; 2873 2874 killer_ptr -> killer.next = attach_data.army; 2875 attach_data.army = killer_ptr; 2876 2877 return; 2878 end free_killer; 2879 2880 expand_kill_ring_element: 2881 procedure; 2882 2883 declare k ptr; 2884 2885 killer_alloc_size = killer.max_size * 2; 2886 allocate killer in (attach_data_area) set (k); 2887 k -> killer.words = killer.words; 2888 2889 if killer.next = addr (killer) /* self-ref */ 2890 then k -> killer.next = k; 2891 else do; 2892 k -> killer.next = killer.next; 2893 killer.next -> killer.prev = k; 2894 end; 2895 2896 if killer.prev = addr (killer) then 2897 k -> killer.prev = k; 2898 else do; 2899 k -> killer.prev = killer.prev; 2900 killer.prev -> killer.next = k; 2901 end; 2902 2903 free attach_data.top_killer -> killer in (attach_data_area); 2904 attach_data.top_killer = k; 2905 2906 end expand_kill_ring_element; 2907 2908 async_or_error: 2909 Error_Detector: 2910 procedure (code); 2911 declare code fixed bin (35); 2912 2913 if code = 0 then 2914 return; 2915 2916 if code = video_et_$window_status_pending then do; 2917 2918 /* can only be async event or screen invalid. If screen invalid, 2919* we clear the window and signal to restart what we were doing. 2920* if just an async event, we need only signal */ 2921 2922 /* now it can also be reconnection or ttp_change */ 2923 2924 if attach_data.status.reconnection | attach_data.status.ttp_change 2925 then call resize_window(); /* this is the *right* way to deal with reconnection */ 2926 2927 attach_data.status_pending = "0"b; 2928 if attach_data.status.screen_invalid then 2929 call window_$clear_window (iocb_ptr, (0)); 2930 /* who knows whats there ? */ 2931 string (attach_data.status) = ""b; 2932 2933 go to ASYNC_EVENT; 2934 end; 2935 2936 /* If we get window_out_of_bounds, assume that it is due to 2937* reconnecting to a video process on a terminal with a smaller 2938* screen. */ 2939 2940 /* This is no longer true, and should not be called, but it is safer to 2941* leave the check in, and shouldn't do any harm */ 2942 2943 else if code = video_et_$out_of_window_bounds then 2944 do; 2945 call resize_window(); 2946 goto ASYNC_EVENT; 2947 end; 2948 2949 else if code ^= 0 then 2950 begin; 2951 declare sub_err_action bit(36) aligned; 2952 2953 declare sub_err_ entry () options (variable); 2954 2955 /* We only tolerate one blow-out per call, avoids looping 2956* printing these error messages */ 2957 2958 if attach_data.debug | ERROR_COUNT > 0 then 2959 sub_err_action = ACTION_CANT_RESTART; 2960 else sub_err_action = ACTION_DEFAULT_RESTART; 2961 2962 ERROR_COUNT = ERROR_COUNT + 1; 2963 2964 call window_$clear_window (iocb_ptr, (0)); 2965 call sub_err_ (code, "window_io_iox_", sub_err_action, null (), (0), ""); 2966 go to ASYNC_EVENT; 2967 2968 end; 2969 2970 end async_or_error; 2971 2972 2973 RETURN: 2974 return; 2975 resize_window: proc(); 2976 2977 dcl 1 auto_window_position_info 2978 aligned like window_position_info; 2979 dcl 1 auto_capabilities_info 2980 aligned like capabilities_info; 2981 2982 /* Try to resize the window to fit on the screen. We may 2983* have been reconnected to a smaller terminal */ 2984 2985 auto_capabilities_info.version = capabilities_info_version_1; 2986 call iox_$control (attach_data.target_iocb_ptr, "get_capabilities", addr (auto_capabilities_info), code); 2987 call async_or_error (code); 2988 2989 /* Start out with the old values. Since we got an error, 2990* one of these values is wrong. */ 2991 auto_window_position_info.extent.width = attach_data.current.columns; 2992 auto_window_position_info.extent.height = attach_data.current.rows; 2993 auto_window_position_info.origin.line = attach_data.line_origin; 2994 auto_window_position_info.origin.column = attach_data.column_origin; 2995 auto_window_position_info.version = window_position_info_version_1; 2996 2997 /* If the window is wider than the screen, knock off the 2998* rightmost columns. */ 2999 if attach_data.current.columns + attach_data.column_origin - 1 > auto_capabilities_info.screensize.columns then 3000 auto_window_position_info.extent.width = auto_capabilities_info.screensize.columns - attach_data.column_origin + 1; 3001 3002 /* If the top of the window is within two lines of the 3003* bottom of the screen (or is off the bottom), make the 3004* window take over the entire screen. */ 3005 if attach_data.current.line_origin > (auto_capabilities_info.screensize.rows - 2) then 3006 auto_window_position_info.origin.line = 1; 3007 3008 /* otherwise shorten the window if it runs off the 3009* bottom of the screen */ 3010 else if (attach_data.current.line_origin + attach_data.current.rows - 1) 3011 > auto_capabilities_info.screensize.rows then 3012 auto_window_position_info.extent.height = 3013 (auto_capabilities_info.screensize.rows - attach_data.line_origin + 1); 3014 3015 call iox_$control (iocb_ptr, "set_window_info", addr (auto_window_position_info), code); 3016 call async_or_error (code); 3017 3018 end resize_window; 3019 3020 raw_write: 3021 procedure (t); 3022 3023 dcl t char (*); 3024 3025 dcl code fixed bin (35); 3026 3027 /* Calling window_$write_raw_text sets the screen_invalid status 3028* bit and the status_pending bit, but no status code is returned. 3029* The next call to some other window_ entrypoint will return 3030* the status_pending code. The iox_ interface assumes that the 3031* user of rawo mode knows what he is doing and resets the status 3032* generated by write_raw_text calls. */ 3033 3034 call window_$write_raw_text (iocb_ptr, t, code); 3035 call async_or_error (code); /* If there was no code, then any status remaining is a result 3036* of the raw output. Reset the status so the next non-raw 3037* window_ call won't error out. */ 3038 attach_data.status_pending = "0"b; 3039 attach_data.status.screen_invalid = "0"b; 3040 attach_data.cursor_valid = "1"b; 3041 return; 3042 3043 end raw_write; 3044 3045 clear_to_end_of_line: 3046 procedure; 3047 3048 dcl code fixed bin (35); 3049 3050 call window_$clear_to_end_of_line (iocb_ptr, code); 3051 call async_or_error (code); 3052 return; 3053 3054 end clear_to_end_of_line; 3055 3056 ring: 3057 procedure; 3058 3059 declare code fixed bin (35); 3060 3061 call window_$bell (iocb_ptr, code); 3062 call async_or_error (code); 3063 end ring; 3064 3065 /* More processing routine. */ 3066 3067 check_more: 3068 procedure; 3069 3070 recheck_more: 3071 if ^attach_data.more_processing then 3072 return; 3073 3074 if (attach_data.more_mode = MORE_MODE_SCROLL) | (attach_data.more_mode = MORE_MODE_FOLD) then 3075 if lines_written_since_read >= (attach_data.current.rows - 1) then 3076 ; 3077 else return; 3078 3079 else if ^((attach_data.line = attach_data.current.rows) & (attach_data.col = 1)) then 3080 return; 3081 3082 call perform_more_break (); 3083 3084 perform_more_break: 3085 procedure; 3086 3087 dcl continue_output bit (1) aligned; 3088 dcl prompt character (80) varying; 3089 dcl (yesses_string, noes_string) 3090 character (40) varying; 3091 dcl i fixed bin; 3092 dcl got_response bit (1) aligned; 3093 dcl response character (1); 3094 dcl r character (1); 3095 dcl break character (1) varying; 3096 dcl 1 more_data like more_info; 3097 3098 dcl quit condition; 3099 3100 dcl ioa_$rsnnl entry () options (variable); 3101 dcl continue_to_signal_ entry (fixed bin (35)); 3102 3103 3104 /* Check to see if the user has supplied his own more handler. */ 3105 if attach_data.more_handler_in_use then do; 3106 continue_output = "1"b; 3107 3108 more_data.version = more_info_version; 3109 more_data.window_iocb_ptr = iocb_ptr; 3110 more_data.more_mode = attach_data.more_mode; 3111 more_data.more_prompt = attach_data.more_prompt; 3112 more_data.more_responses.n_yeses = attach_data.more_responses.n_yeses; 3113 more_data.more_responses.n_noes = attach_data.more_responses.n_noes; 3114 more_data.more_responses.more_yeses = attach_data.more_responses.more_yeses; 3115 more_data.more_responses.more_noes = attach_data.more_responses.more_noes; 3116 3117 /* make sure that QUIT during more break will be seen */ 3118 on quit 3119 begin; 3120 attach_data.lines_written_since_read = 0; 3121 call get_to_next_line (); 3122 call continue_to_signal_ ((0)); 3123 end; 3124 3125 call attach_data.more_handler (addr (more_data), continue_output, code); 3126 3127 revert quit; 3128 3129 if code = video_et_$window_status_pending then do; 3130 attach_data.status_pending = "0"b; 3131 string (attach_data.status) = ""b; 3132 go to recheck_more; 3133 end; 3134 call async_or_error (code); 3135 3136 if continue_output then 3137 goto CONTINUE_OUTPUT; 3138 else goto ABORT_OUTPUT; 3139 end; 3140 3141 /* No user supplied more handle, so do it ourselves. */ 3142 3143 yesses_string = ""; 3144 do i = 1 to attach_data.n_yeses; 3145 yesses_string = yesses_string || flat_rep (substr (attach_data.more_yeses, i, 1)); 3146 yesses_string = yesses_string || " "; 3147 end; 3148 3149 noes_string = ""; 3150 do i = 1 to attach_data.n_noes; 3151 noes_string = noes_string || flat_rep (substr (attach_data.more_noes, i, 1)); 3152 noes_string = noes_string || " "; 3153 end; 3154 3155 call ioa_$rsnnl (attach_data.more_prompt, prompt, (0), yesses_string, noes_string); 3156 3157 do while ("1"b); 3158 3159 /* Make sure that QUIT during more break will get seen */ 3160 on quit 3161 begin; 3162 attach_data.lines_written_since_read = 0; 3163 call get_to_next_line; 3164 call continue_to_signal_ ((0)); 3165 end; 3166 3167 /* What should be done if the more prompt is bigger than the 3168* window? For now we will just truncate it. */ 3169 3170 if length (rtrim (prompt)) > attach_data.current.columns then 3171 prompt = substr (prompt, 1, attach_data.current.columns); 3172 3173 call window_$write_sync_read (iocb_ptr, rtrim (prompt), (1), response, (0), break, code); 3174 3175 revert quit; 3176 3177 /* Already printed prompt once, don't again. */ 3178 prompt = ""; 3179 3180 if code = video_et_$window_status_pending then do; 3181 /* something in this window went off */ 3182 attach_data.status_pending = "0"b; 3183 string (attach_data.status) = ""b; 3184 go to recheck_more; 3185 end; 3186 call async_or_error (code); 3187 3188 if length (break) = 1 then 3189 r = break; 3190 else r = response; 3191 3192 got_response = "1"b; 3193 3194 verify_response: 3195 begin; 3196 3197 dcl the_yeas character (attach_data.n_yeses) defined (attach_data.more_yeses) position (1); 3198 dcl the_nays character (attach_data.n_noes) defined (attach_data.more_noes) position (1); 3199 3200 if index (the_yeas, r) > 0 then 3201 continue_output = "1"b; 3202 3203 else if index (the_nays, r) > 0 then 3204 continue_output = "0"b; 3205 3206 else do; 3207 got_response = "0"b; 3208 call ring; 3209 end; 3210 3211 end verify_response; 3212 3213 if got_response then 3214 if continue_output then 3215 goto CONTINUE_OUTPUT; 3216 else goto ABORT_OUTPUT; 3217 3218 end; /* do while */ 3219 3220 ABORT_OUTPUT: 3221 if attach_data.more_mode = MORE_MODE_SCROLL then do; 3222 call window_$position_cursor (iocb_ptr, attach_data.current.rows, 1, code); 3223 call async_or_error (code); 3224 call clear_to_end_of_line; 3225 end; 3226 else if attach_data.more_mode = MORE_MODE_FOLD then do; 3227 call window_$position_cursor (iocb_ptr, attach_data.cursor_position.line, 1, code); 3228 call async_or_error (code); 3229 call clear_to_end_of_line; 3230 end; 3231 else do; /* WRAP or CLEAR, so get to top of window. */ 3232 if attach_data.more_mode = MORE_MODE_WRAP then do; 3233 call window_$position_cursor (iocb_ptr, attach_data.current.rows, 1, code); 3234 call async_or_error (code); 3235 call clear_to_end_of_line; 3236 call window_$overwrite_text (iocb_ptr, "(output discarded)", code); 3237 call async_or_error (code); 3238 end; 3239 call get_to_next_line; 3240 end; 3241 3242 attach_data.lines_written_since_read = 0; 3243 3244 call window_$sync (iocb_ptr, code); 3245 call async_or_error (code); 3246 3247 call abort_output (); /* does not return */ 3248 3249 CONTINUE_OUTPUT: 3250 if (attach_data.more_mode = MORE_MODE_SCROLL) then do; 3251 call window_$position_cursor (iocb_ptr, attach_data.line, 1, code); 3252 call async_or_error (code); 3253 call clear_to_end_of_line; 3254 end; 3255 3256 else if (attach_data.more_mode = MORE_MODE_FOLD) then do; 3257 call window_$position_cursor (iocb_ptr, attach_data.line, 1, code); 3258 call async_or_error (code); 3259 call clear_to_end_of_line; 3260 call window_$overwrite_text (iocb_ptr, "--continuing--", code); 3261 call async_or_error (code); 3262 call get_to_next_line; 3263 end; 3264 3265 else if (attach_data.more_mode = MORE_MODE_WRAP) then do; 3266 call window_$position_cursor (iocb_ptr, attach_data.line, 1, code); 3267 call async_or_error (code); 3268 call clear_to_end_of_line; 3269 call window_$overwrite_text (iocb_ptr, "--continuing--", code); 3270 call async_or_error (code); 3271 call get_to_next_line; 3272 end; 3273 3274 else call get_to_next_line; 3275 3276 attach_data.lines_written_since_read = 0; 3277 3278 return; 3279 3280 flat_rep: 3281 procedure (c) returns (char (32) varying); 3282 3283 dcl c character (1); 3284 3285 if c = byte (bin ("015"b3)) then 3286 return ("RETURN"); 3287 if c < " " then 3288 return ("^" || byte (rank (c) + rank ("@"))); 3289 if c = " " then 3290 return ("SPACE"); 3291 if c = byte (bin ("177"b3)) then 3292 return ("DEL"); 3293 return (c); 3294 3295 end flat_rep; 3296 3297 end perform_more_break; 3298 3299 end check_more; 3300 3301 abort_output: 3302 procedure; 3303 3304 attach_data.discard_output = "1"b; 3305 Code = 0; 3306 go to RETURN; 3307 3308 end abort_output; 3309 3310 reset_more_entry: 3311 entry (Iocb_ptr); 3312 3313 iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr; 3314 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 3315 3316 attach_data.discard_output = "0"b; 3317 3318 return; 3319 3320 put_chars: 3321 entry (Iocb_ptr, Buffer_ptr, Buffer_len, Code); 3322 3323 iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr; 3324 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 3325 3326 Code = 0; 3327 ERROR_COUNT = 0; 3328 PROCESSED_SO_FAR = 0; /* as soon as ASYNC_EVENT is set this must be valid. stack garbage won't do. */ 3329 3330 if attach_data.discard_output then 3331 return; 3332 3333 if attach_data.rawo then do; 3334 RESTART_PUT_RAW_CHARS: 3335 ASYNC_EVENT = RESTART_PUT_RAW_CHARS; 3336 call raw_write (Buffer); 3337 goto put_chars_return; 3338 end; 3339 3340 ASYNC_EVENT = RESTART_PUT_CHARS; 3341 3342 /* Cover our ass against funny (ha ha) cursor positions */ 3343 3344 if attach_data.line > attach_data.current.rows /* IMPOSSIBLE */ 3345 then do; 3346 call window_$position_cursor (iocb_ptr, attach_data.current.rows, 1, code); 3347 call async_or_error (code); 3348 end; 3349 3350 call clear_to_end_of_line; /* neater displays */ 3351 call put_out_chars (Buffer); 3352 3353 put_chars_return: 3354 call window_$sync (iocb_ptr, (0)); 3355 return; 3356 3357 RESTART_PUT_CHARS: 3358 begin; 3359 3360 dcl reput_str character (length (Buffer) - PROCESSED_SO_FAR) defined (Buffer) 3361 position (PROCESSED_SO_FAR + 1); 3362 if length (reput_str) > 0 then 3363 call put_out_chars (reput_str); 3364 go to put_chars_return; 3365 end; 3366 3367 get_chars: 3368 entry (Iocb_ptr, Buffer_ptr, Buffer_len, N_returned, Code); 3369 3370 Code = 0; 3371 N_returned = 0; 3372 3373 iocb_ptr = Iocb_ptr -> iocb.actual_iocb_ptr; 3374 attach_data_ptr = iocb_ptr -> iocb.attach_data_ptr; 3375 3376 attach_data.discard_output = "0"b; 3377 attach_data.lines_written_since_read = 0; 3378 3379 if Buffer_len = 0 | Buffer_ptr = null () then 3380 return; 3381 3382 /* Read all the characters the user has typed so far. */ 3383 do char_count = 1 by 1; 3384 call window_$get_one_unechoed_char (iocb_ptr, char_varying, "0"b /* don't block */, Code); 3385 if Code ^= 0 then 3386 return; 3387 3388 /* No more characters. */ 3389 if length (char_varying) = 0 then do; 3390 N_returned = char_count - 1; 3391 return; 3392 end; 3393 3394 substr (Buffer, char_count, 1) = char_varying; 3395 3396 /* If we are supposed to echo, try echoing through put_chars. 3397* This is pretty weird, but gets output conversions done. */ 3398 3399 if ^attach_data.suppress_echo then do; 3400 char_nonvarying = char_varying; 3401 call iox_$put_chars (iocb_ptr, addr (char_nonvarying), 1, Code); 3402 if Code ^= 0 then 3403 return; 3404 end; 3405 end; 3406 3407 return; 3408 3409 cl_pusher: 3410 procedure (cl_arg); 3411 declare 1 cl_arg aligned, 3412 2 resetread bit (1) unaligned, 3413 2 pad bit (35) unaligned; 3414 3415 /* We want to call the usual cl_intermediary, but when it returns, 3416* we want to pretend something asynchronous has happened, which it has. */ 3417 3418 call REAL_CL_INTERMEDIARY (cl_arg); 3419 3420 go to ASYNC_EVENT; 3421 3422 end cl_pusher; 3423 3424 1 1 /* Begin include file window_io_attach_data_.incl.pl1 BIM June 1981 */ 1 2 1 3 /* Modified by Chris Jones December 1981 to add MORE_MODE_FOLD */ 1 4 /* Modified by William York 26 January 1982 to add more_handler_in_use 1 5* and more_handler to the attach_data structure. */ 1 6 /* Modified 18 October 1982 by WMY to add the window_image_ptr, 1 7* conversion_tct_table and token_characters. */ 1 8 /* Modified 30 September 1983 by Jon A. Rochlis to add column_origin for 1 9* partial screen width windows. */ 1 10 /* Modified 8 January 1983 by JR to delete attach_data.capabilites. See 1 11* window_io_ and wioctl_ for more info. */ 1 12 /* Modified 5 March 1984 by Barmar to add dispatch_table.name, .description, 1 13* and .info_path. */ 1 14 /* Modified 22 March 1984 by Barmar to add attach_data.auditor_iocb_ptr. */ 1 15 /* Modified 01 September 1984 by JR to add edited mode. */ 1 16 1 17 1 18 /****^ HISTORY COMMENTS: 1 19* 1) change(86-05-18,GDixon), approve(86-05-18,MCR7357), 1 20* audit(86-06-16,Farley), install(86-07-18,MR12.0-1098): 1 21* Modify attach_data.conversion_tct_table to make it aligned. When tct_ was 1 22* replaced by find_char_, the new calling sequence required an aligned 1 23* table. 1 24* END HISTORY COMMENTS */ 1 25 1 26 1 27 /* format: style3 */ 1 28 declare attach_data_ptr pointer; 1 29 declare 1 attach_data aligned based (attach_data_ptr), 1 30 2 window_id bit (36) aligned, 1 31 2 async_count fixed bin, 1 32 2 attach_description 1 33 character (128) var, /* attach description */ 1 34 2 open_description 1 35 character (64) varying, 1 36 2 target_iocb_ptr pointer, 1 37 2 flags, 1 38 3 discard_output 1 39 bit (1) unal, /* more processing: throw away all output */ 1 40 3 debug bit (1) unal, 1 41 3 more_processing 1 42 bit (1) unal, /* more mode */ 1 43 3 vertsp bit (1) unal, /* vertsp mode */ 1 44 3 can bit (1) unal, /* can mode */ 1 45 3 esc bit (1) unal, /* can mode */ 1 46 3 erkl bit (1) unal, /* erkl mode */ 1 47 3 rawo bit (1) unal, /* rawo mode */ 1 48 3 red bit (1) unal, /* red mode */ 1 49 3 ctl_char bit (1) unal, /* allow ctrl chars input? */ 1 50 3 status_pending 1 51 bit (1) unal, 1 52 3 cursor_valid bit (1) unal, 1 53 3 suppress_echo bit (1) unal, 1 54 3 ignore_status bit (1) unal, 1 55 3 edited bit (1) unal, /* edited mode */ 1 56 3 pad bit (21) unal, 1 57 2 status aligned like window_status, 1 58 2 lines_written_since_read 1 59 fixed bin, /* more processing */ 1 60 2 cursor_position, /* Where in this window */ 1 61 3 line fixed bin, /* line number */ 1 62 3 col fixed bin, /* column */ 1 63 3 row_at_rawo fixed bin, 1 64 3 col_at_rawo fixed bin, /* when we went raw */ 1 65 2 more_mode fixed bin, /* which flavor */ 1 66 2 more_prompt character (80), /* "MORE?" */ 1 67 2 more_responses, 1 68 3 n_yeses fixed bin, /* number valid */ 1 69 3 n_noes fixed bin, 1 70 3 more_yeses character (32) unaligned, /* at most 32 yeses */ 1 71 3 more_noes character (32) unaligned, 1 72 2 editing_chars, 1 73 3 erase_char character (1), 1 74 3 kill_char character (1), 1 75 3 input_escape_char 1 76 character (1), /* normally "\" */ 1 77 2 breaks bit (128) unaligned, 1 78 2 line_editor_breaks 1 79 bit (128) unaligned, 1 80 2 current, /* describes us */ 1 81 3 rows fixed bin, /* how many lines */ 1 82 3 columns fixed bin, /* how wide lines in this window are */ 1 83 3 line_origin fixed bin, /* on containing screen (terminal) */ 1 84 3 column_origin fixed bin, /* on containing screen (terminal) */ 1 85 2 kill_ring_info, 1 86 3 top_killer ptr, /* top of ring */ 1 87 3 army ptr, /* surplus killers kept here */ 1 88 2 output_cv_ptr ptr, /* to cv_trans */ 1 89 2 special_ptr ptr, /* to special_chars */ 1 90 2 saved_buffer_ptr /* for saving text across editor calls */ 1 91 pointer, 1 92 2 dispatch_table_ptr /* for editor key bindings */ 1 93 pointer, 1 94 2 more_handler_in_use 1 95 bit(1), 1 96 2 more_handler entry (pointer, bit(1) aligned, fixed bin(35)), 1 97 2 conversion_tct_table 1 98 char(512), 1 99 2 token_character_count /* count of valid chars */ 1 100 fixed bin, 1 101 2 token_characters /* token delimiters for line editor */ 1 102 char(128) unaligned, 1 103 2 window_image_ptr pointer, /* to character array for this window */ 1 104 2 auditor_iocb_ptr pointer; /* set by set_audit_iocb_ptr control order */ 1 105 1 106 dcl ( 1 107 MORE_MODE_SCROLL init (1), 1 108 MORE_MODE_CLEAR init (2), 1 109 MORE_MODE_WRAP init (3), 1 110 MORE_MODE_FOLD init (4) 1 111 ) fixed bin internal static options (constant); 1 112 1 113 dcl attach_data_area area based (get_system_free_area_ ()); 1 114 1 115 declare get_system_free_area_ 1 116 entry returns (pointer); 1 117 1 118 dcl 1 killer based (attach_data.top_killer), 1 119 2 next pointer, /* if you rotate */ 1 120 2 prev pointer, /* dbl thread for conven. */ 1 121 2 max_size fixed bin (21), 1 122 2 words character (killer_alloc_size refer (killer.max_size)) varying; 1 123 1 124 dcl killer_alloc_size fixed bin; 1 125 dcl killer_initial_alloc_size 1 126 fixed bin init (128) internal static options (constant); 1 127 declare breaks_array (0:127) bit (1) unaligned defined (attach_data.breaks) position (1); 1 128 declare line_editor_breaks_array 1 129 (0:127) bit (1) unaligned defined (attach_data.line_editor_breaks) position (1); 1 130 1 131 dcl valid_token_characters char(attach_data.token_character_count) based (addr (attach_data.token_characters)); 1 132 1 133 /* Each window has its own window image, which must be re-allocated if the 1 134* window size changes. */ 1 135 dcl window_image (attach_data.current.rows) char (attach_data.current.columns) 1 136 based (attach_data.window_image_ptr); 1 137 1 138 /* Single based string for clearing. */ 1 139 dcl window_image_string char(attach_data.current.rows * attach_data.current.columns) based (window_image_ptr); 1 140 1 141 /* editor key binding dispatch table. 1 142* 1 143*If type = 0, the keystroke is associated with the editor routine specified by 1 144*routine. Simply call the routine. 1 145* 1 146*If type < 0, the keystroke is a prefix character, and the pointer in next_table 1 147*points to the next dispatch table. 1 148* 1 149*If type > 0, it is an index into the table of builtin editor commands (i.e. 1 150*the editor routines implemented by this module). Perform a quick call of the 1 151*builtin routine. */ 1 152 1 153 dcl dispatch_table_ptr pointer; 1 154 1 155 dcl 1 dispatch_table aligned based (dispatch_table_ptr), 1 156 2 key (0:127), 1 157 3 type fixed bin, 1 158 3 pad fixed bin, 1 159 3 next_table pointer, 1 160 3 routine entry (pointer, fixed bin(35)), 1 161 3 numarg_action fixed bin, /* only for external routines */ 1 162 3 name char (64) varying, 1 163 3 description char (256) varying, 1 164 3 info_path, 1 165 4 info_dir char (168), 1 166 4 info_entry char (32); 1 167 2 1 /* Begin include file window_editor_values.incl.pl1 */ 2 2 2 3 /* Spring 1983 by William M. York */ 2 4 /* Modifed June 1983 by Jon A. Rochlis to add NUMBER_READER_N builtins, word 2 5* casing builtins, twiddle word, and numarg actions */ 2 6 /* Modified 7 August 1983 by JR to add string arrays. Be sure 2 7* everything is kept in sync. If you add a new editor builtin 2 8* make sure you update HIGHEST_BUILTIN_ROUTINE_VALUE, add an element 2 9* to the string array, and bump its dimension. */ 2 10 /* Modified 5 March 1984 by Barmar to add the builtin_descriptions array 2 11* and BUILTIN_INFO_* */ 2 12 2 13 dcl (EXTERNAL_ROUTINE init(0), 2 14 FORWARD_CHARACTER init(1), 2 15 BACKWARD_CHARACTER init(2), 2 16 FORWARD_DELETE_CHARACTER init(3), 2 17 BACKWARD_DELETE_CHARACTER 2 18 init(4), 2 19 MOVE_TO_END_OF_LINE init(5), 2 20 MOVE_TO_BEGINNING_OF_LINE 2 21 init(6), 2 22 KILL_TO_END_OF_LINE init(7), 2 23 KILL_TO_BEGINNING_OF_LINE 2 24 init(8), 2 25 FORWARD_WORD init(9), 2 26 BACKWARD_WORD init(10), 2 27 FORWARD_DELETE_WORD init(11), 2 28 BACKWARD_DELETE_WORD init(12), 2 29 QUOTE_CHARACTER init(13), 2 30 CLEAR_WINDOW init(14), 2 31 TWIDDLE_CHARACTERS init(15), 2 32 DISPLAY_EDITOR_DOCUMENTATION 2 33 init(16), 2 34 SELF_INSERT init(17), 2 35 YANK_FROM_KILL_RING init(18), 2 36 YANK_PREVIOUS_FROM_KILL_RING 2 37 init(19), 2 38 TERMINATE_INPUT_LINE init(20), 2 39 UNDEFINED init(21), 2 40 PROCESS_INPUT_ESCAPE init(22), 2 41 NUMBER_READER_0 init(23), 2 42 NUMBER_READER_1 init(24), 2 43 NUMBER_READER_2 init(25), 2 44 NUMBER_READER_3 init(26), 2 45 NUMBER_READER_4 init(27), 2 46 NUMBER_READER_5 init(28), 2 47 NUMBER_READER_6 init(29), 2 48 NUMBER_READER_7 init(30), 2 49 NUMBER_READER_8 init(31), 2 50 NUMBER_READER_9 init(32), 2 51 MULTIPLIER init(33), 2 52 LOWERCASE_WORD init(34), 2 53 UPPERCASE_WORD init(35), 2 54 INITIAL_CAPITAL init(36), 2 55 TWIDDLE_WORDS init(37), 2 56 NEGATIVE_NUMBER_READER init(38), 2 57 /* the following must be updated as new internal routines are added 2 58* in order for set_editor_key_bindings to work */ 2 59 HIGHEST_BUILTIN_ROUTINE_VALUE 2 60 init(38) 2 61 ) fixed bin static options(constant); 2 62 2 63 dcl builtin_routine_names (-1:38) char(32) static options (constant) init 2 64 ("PREFIX_KEY", 2 65 "USER_DEFINED_COMMAND", 2 66 "FORWARD_CHARACTER", 2 67 "BACKWARD_CHARACTER", 2 68 "FORWARD_DELETE_CHARACTER", 2 69 "BACKWARD_DELETE_CHARACTER", 2 70 "MOVE_TO_END_OF_LINE", 2 71 "MOVE_TO_BEGINNING_OF_LINE", 2 72 "KILL_TO_END_OF_LINE", 2 73 "KILL_TO_BEGINNING_OF_LINE", 2 74 "FORWARD_WORD", 2 75 "BACKWARD_WORD", 2 76 "FORWARD_DELETE_WORD", 2 77 "BACKWARD_DELETE_WORD", 2 78 "QUOTE_CHARACTER", 2 79 "CLEAR_WINDOW", 2 80 "TWIDDLE_CHARACTERS", 2 81 "DISPLAY_EDITOR_DOCUMENTATION", 2 82 "SELF_INSERT", 2 83 "YANK_FROM_KILL_RING", 2 84 "YANK_PREVIOUS_FROM_KILL_RING", 2 85 "TERMINATE_INPUT_LINE", 2 86 "UNDEFINED", 2 87 "PROCESS_INPUT_ESCAPE", 2 88 "NUMBER_READER_0", 2 89 "NUMBER_READER_1", 2 90 "NUMBER_READER_2", 2 91 "NUMBER_READER_3", 2 92 "NUMBER_READER_4", 2 93 "NUMBER_READER_5", 2 94 "NUMBER_READER_6", 2 95 "NUMBER_READER_7", 2 96 "NUMBER_READER_8", 2 97 "NUMBER_READER_9", 2 98 "MULTIPLIER", 2 99 "LOWERCASE_WORD", 2 100 "UPPERCASE_WORD", 2 101 "INITIAL_CAPITAL", 2 102 "TWIDDLE_WORDS", 2 103 "NEGATIVE_NUMBER_READER"); 2 104 2 105 dcl builtin_descriptions (-1:38) char (128) varying static options (constant) init 2 106 ("Reads another key and dispatches.", 2 107 "A user-defined command for which no description was supplied.", 2 108 "Moves forward over one character.", 2 109 "Moves backward over one character.", 2 110 "Deletes the character at the cursor.", 2 111 "Deletes the character to the left of the cursor.", 2 112 "Moves to the end of the input line.", 2 113 "Moves to the beginning of the input line.", 2 114 "Deletes the text from the cursor to the end of the input line, saving it on the kill ring.", 2 115 "Deletes the text from the cursor to the beginning of the input line, saving it on the kill ring.", 2 116 "Moves to the end of the current or following word.", 2 117 "Moves to the beginning of the current or preceding word.", 2 118 "Deletes the text from the cursor to the end of the current word, saving it on the kill ring.", 2 119 "Deletes the text from the cursor to the beginning of the current word, saving it on the kill ring.", 2 120 "Inserts the next character typed into the input line.", 2 121 "Clears the input window, and redisplays the current input line at the top of the window.", 2 122 "Interchanges the two characters to the left of the cursor.", 2 123 "Displays the list of standard input editor commands.", 2 124 "Inserts the character typed.", 2 125 "Inserts the top item from the kill ring.", 2 126 "Deletes the text just yanked, rotate the kill ring, and insert the new top item.", 2 127 "Enters the input line.", 2 128 "Undefined key - rings the terminal bell.", 2 129 "Does appropriate ""backslash-style"" input escape processing.", 2 130 (10) ("Begins reading a numeric argument."), 2 131 "If followed by digits, uses them as the numeric argument, otherwise multiplies the num-arg by four.", 2 132 "Lowercases the current word.", 2 133 "Uppercases the current word.", 2 134 "Uppercases the first letter of the current word, and lowercases the rest of the letters.", 2 135 "Interchange the current word and the preceding word.", 2 136 "Begins reading a negative numeric argument."); 2 137 2 138 dcl BUILTIN_INFO_DIR char (168) static options (constant) init (">doc>info"); 2 139 dcl BUILTIN_INFO_ENTRY char (32) static options (constant) init ("video_editing.gi"); 2 140 2 141 /* numeric argument action */ 2 142 2 143 dcl (REJECT init(0), 2 144 IGNORE init(1), 2 145 REPEAT init(2), 2 146 PASS init(3), 2 147 /* this should be updated if new numarg actions are added */ 2 148 HIGHEST_NUMARG_ACTION_VALUE 2 149 init(3) 2 150 ) fixed bin static options(constant); 2 151 2 152 /* strings for numarg actions */ 2 153 2 154 dcl numarg_action_names (0:3) char(6) static options (constant) init 2 155 ("REJECT", 2 156 "INGORE", 2 157 "REPEAT", 2 158 "PASS"); 2 159 2 160 /* end include file window_editor_values.incl.pl1 */ 1 168 3 1 /* begin include file window_status.incl.pl1 */ 3 2 /* Modified 28 March 1984 by Jon A. Rochlis to add terminal type change 3 3* and reconnection stuff. */ 3 4 /* format: style3 */ 3 5 /* interrupts that an application can recieve from a window */ 3 6 3 7 declare window_status_string 3 8 bit (36) unaligned; 3 9 3 10 declare 1 window_status aligned, 3 11 2 screen_invalid bit (1) unaligned, 3 12 2 async_change bit (1) unaligned, 3 13 2 ttp_change bit (1) unaligned, 3 14 2 reconnection bit (1) unaligned, 3 15 2 pad bit (32) unaligned; 3 16 3 17 declare ( 3 18 W_STATUS_SCREEN_INVALID 3 19 init ("1"b), 3 20 W_STATUS_ASYNC_EVENT 3 21 init ("01"b), 3 22 W_STATUS_TTP_CHANGE 3 23 init ("001"b), 3 24 W_STATUS_RECONNECTION 3 25 init ("0001"b) 3 26 ) bit (36) aligned internal static options (constant); 3 27 3 28 /* end include file window_status.incl.pl1 */ 1 169 4 1 /* BEGIN INCLUDE FILE terminal_capabilities.incl.pl1 BIM May 1981 */ 4 2 /* format: style3 */ 4 3 dcl 1 capabilities_info aligned based (capabilities_info_ptr), 4 4 2 version fixed bin, 4 5 2 screensize, 4 6 3 columns fixed bin, 4 7 3 rows fixed bin, 4 8 2 flags, 4 9 3 scroll_region bit (1) unal, 4 10 3 insert_chars bit (1) unal, 4 11 3 insert_mode bit (1) unal, 4 12 3 delete_chars bit (1) unal, 4 13 3 overprint bit (1) unal, 4 14 3 pad bit (31) unal, 4 15 2 line_speed fixed bin; /* chars per sec */ 4 16 4 17 dcl (capabilities_info_version_1, capabilities_info_version) 4 18 fixed bin internal static init (1) options (constant); 4 19 dcl capabilities_info_ptr 4 20 pointer; 4 21 4 22 /* END INCLUDE FILE terminal_capabilities.incl.pl1 */ 1 170 1 171 1 172 /* End include file window_io_attach_data_.incl.pl1 */ 3425 3426 5 1 /* Begin include file window_line_editor.incl.pl1 5 2* William M. York, February, 1983 */ 5 3 /* Modified April 1984 by Jon A. Rochlis to add the suppress_redisplay 5 4* flag, to be used when returning from an editor function. */ 5 5 5 6 dcl line_editor_info_ptr pointer; 5 7 5 8 dcl 1 line_editor_info aligned based (line_editor_info_ptr), 5 9 2 version char(8), 5 10 2 iocb_ptr pointer, /* to current window */ 5 11 2 repetition_count fixed bin, /* number of times to perform operation */ 5 12 2 flags, 5 13 3 return_from_editor bit(1) unaligned, /* to end editing session */ 5 14 3 merge_next_kill bit(1) unaligned, /* don't touch */ 5 15 3 old_merge_next_kill bit(1) unaligned, /* don't touch */ 5 16 3 last_kill_direction bit(1) unaligned, /* don't touch */ 5 17 3 numarg_given bit(1) unaligned, 5 18 3 suppress_redisplay bit(1) unaligned, /* only meaningful if return_from_editor is set */ 5 19 3 pad bit(28) unaligned, 5 20 2 user_data_ptr pointer, /* for carrying user state information */ 5 21 2 cursor_index fixed bin(21), /* 0 < cursor_index <= line_length + 1 */ 5 22 2 line_length fixed bin(21), /* 0 <= line_length <= length (input_buffer) */ 5 23 2 input_buffer character(512) unaligned, 5 24 2 key_sequence character(128); /* key sequence which caused user routine to be invoked */ 5 25 5 26 dcl line_editor_input_line char(line_editor_info.line_length) based (addr (line_editor_info.input_buffer)); 5 27 5 28 dcl line_editor_info_version_1 5 29 char(8) static options (constant) init ("lei00001"); 5 30 5 31 dcl line_editor_info_version_2 5 32 char(8) static options (constant) init ("lei00002"); 5 33 5 34 /* User supplied editor routines may want to preserve state information of 5 35* their own across calls. user_data_ptr points to a chain of data structures 5 36* that these routines may use. The structures should all have the same header 5 37* (declared here), and the id field can be used to identify which structures 5 38* belong to which routines. */ 5 39 5 40 dcl 1 line_editor_user_data_header 5 41 aligned based, 5 42 2 id fixed bin, 5 43 2 next_user_data_ptr pointer; 5 44 5 45 /* End window_line_editor.incl.pl1 */ 3427 3428 6 1 /* begin include fine window_dcls.incl.pl1 BIM June 1981 */ 6 2 /* Modified 9 October 1983 by Jon A. Rochlis to add window_$edit_line. */ 6 3 6 4 /* format: style3 */ 6 5 6 6 declare window_$bell entry (pointer, fixed binary (35)); 6 7 declare window_$clear_region 6 8 entry (pointer, fixed binary, fixed binary, fixed binary, fixed binary, fixed binary (35)); 6 9 declare window_$clear_to_end_of_line 6 10 entry (pointer, fixed binary (35)); 6 11 declare window_$clear_to_end_of_window 6 12 entry (pointer, fixed binary (35)); 6 13 declare window_$clear_window 6 14 entry (pointer, fixed binary (35)); 6 15 declare window_$delete_chars 6 16 entry (pointer, fixed binary, fixed binary (35)); 6 17 declare window_$get_cursor_position 6 18 entry (pointer, fixed binary, fixed binary, fixed binary (35)); 6 19 6 20 /* Call window_$get_echoed_chars (iocb_ptr, n_to_read, read_buffer, n_read, read_break, code); */ 6 21 6 22 declare window_$get_echoed_chars 6 23 entry (pointer, fixed binary (21), character (*), fixed binary (21), character (1) var, 6 24 fixed binary (35)); 6 25 declare window_$get_unechoed_chars 6 26 entry (pointer, fixed binary (21), character (*), fixed binary (21), character (1) var, 6 27 fixed binary (35)); 6 28 declare window_$insert_text entry (pointer, character (*), fixed binary (35)); 6 29 declare window_$overwrite_text 6 30 entry (pointer, character (*), fixed binary (35)); 6 31 declare window_$position_cursor 6 32 entry (pointer, fixed binary, fixed binary, fixed binary (35)); 6 33 6 34 /* Call window_$position_cursor_rel (iocb_ptr, delta_line, delta_column, code); */ 6 35 6 36 declare window_$position_cursor_rel 6 37 entry (pointer, fixed binary, fixed binary, fixed binary (35)); 6 38 6 39 /* Call window_$scroll_region (iocb_ptr, first_line_of_region, n_lines_of_region, distance_to_scroll_region_negative_is_up, 6 40* code); */ 6 41 6 42 declare window_$scroll_region 6 43 entry (pointer, fixed binary, fixed binary, fixed binary, fixed binary (35)); 6 44 declare window_$sync entry (pointer, fixed binary (35)); 6 45 6 46 /* Call window_$write_raw_text (iocb_ptr, text_string, code); */ 6 47 6 48 declare window_$write_raw_text 6 49 entry (pointer, character (*), fixed binary (35)); 6 50 6 51 /* Call window_$write_sync_read (iocb_ptr, prompt_string, n_to_read, read_buffer, n_read, break_char, code); */ 6 52 6 53 declare window_$write_sync_read 6 54 entry (pointer, character (*), fixed bin (21), character (*), fixed binary (21), 6 55 character (1) var, fixed binary (35)); 6 56 6 57 /* Call window_$change_line (iocb_ptr, new_line, code); */ 6 58 6 59 declare window_$change_line entry (pointer, fixed binary, fixed binary (35)); 6 60 6 61 /* Call window_$change_column (iocb_ptr, new_column, code); */ 6 62 6 63 declare window_$change_column 6 64 entry (pointer, fixed binary, fixed binary (35)); 6 65 6 66 /* Call window_$get_one_unechoed (iocb_ptr, char_or_len_0, block_flag, code); */ 6 67 declare ( 6 68 window_$get_one_unechoed, 6 69 window_$get_one_unechoed_char 6 70 ) entry (pointer, character (1) var, bit (1) aligned, fixed binary (35)); 6 71 6 72 declare window_$create entry (pointer, pointer, pointer, fixed binary (35)); 6 73 6 74 declare window_$destroy entry (pointer, fixed binary (35)); 6 75 6 76 declare window_$edit_line entry (pointer, pointer, pointer, fixed bin(21), fixed bin(21), fixed bin(35)); 6 77 6 78 /* call window_$edit_line (iocb_ptr, window_edit_line_info_ptr, buffer_ptr, 6 79* buffer_len, n_returned, code); */ 6 80 6 81 6 82 /* end include file window_dcls.incl.pl1 */ 3429 3430 7 1 /* BEGIN INCLUDE FILE ... window_control_info.incl.pl1 JRD */ 7 2 /* format: style3 */ 7 3 7 4 /* Modified 26 January 1982 by William York to add the set_more_handler 7 5* and reset_more_handler control orders. */ 7 6 /* Modified October 1982 by WMY to add set and get_token_characters, 7 7* set and get_more_prompt. */ 7 8 /* Modified February 1983 by WMY to add the line_editor_key_binding_info 7 9* structure. */ 7 10 /* Modified 30 September 1983 by Jon A. Rochlis to add the origin.column for 7 11* partial screen width windows. */ 7 12 /* Modified 9 October 1983 by JR to add version 1 window_edit_line_info. 7 13* This should be removed when window_info.incl.pl1 is created. */ 7 14 /* Modified 29 February 1984 by Barmar to add version 1 7 15* get_editor_key_bindings_info. */ 7 16 /* Modified 1 March 1984 by Barmar to add version 1 7 17* set_editor_key_bindings_info. */ 7 18 /* Modified 2 March 1984 by Barmar to upgrade to version 3 7 19* line_editor_key_bindings_info, which includes the name, description, and 7 20* info path */ 7 21 7 22 /* structure for the set_window_info and get_window_info 7 23* control orders. */ 7 24 7 25 dcl 1 window_position_info 7 26 based (window_position_info_ptr), 7 27 2 version fixed bin, 7 28 2 origin, 7 29 3 column fixed bin, 7 30 3 line fixed bin, 7 31 2 extent, 7 32 3 width fixed bin, 7 33 3 height fixed bin; 7 34 7 35 dcl (window_position_info_version, window_position_info_version_1) 7 36 fixed bin internal static init (1) options (constant); 7 37 dcl window_position_info_ptr 7 38 pointer; 7 39 7 40 /* structure for the set_window_status and get_window_status 7 41* control orders */ 7 42 7 43 declare window_status_info_ptr 7 44 pointer; 7 45 declare 1 window_status_info 7 46 aligned based (window_status_info_ptr), 7 47 2 version fixed bin, 7 48 2 status_string bit (36) aligned; /* string (window_status) */ 7 49 /* see window_status.incl.pl1 for the contents of this string */ 7 50 7 51 7 52 declare (window_status_version, window_status_version_1) 7 53 fixed bin internal static init (1) options (constant); 7 54 7 55 /* info structure for the set_more_responses and get_more_responses control 7 56* orders */ 7 57 7 58 7 59 dcl 1 more_responses_info 7 60 aligned based (more_responses_info_ptr), 7 61 2 version fixed bin, 7 62 2 n_yeses fixed bin, /* how many valid characters in the strings below */ 7 63 2 n_noes fixed bin, 7 64 2 yeses char (32) unaligned, 7 65 2 noes char (32) unaligned; 7 66 7 67 dcl (more_responses_info_version_1, more_responses_version) 7 68 fixed bin internal static init (1) options (constant); 7 69 dcl more_responses_info_ptr 7 70 pointer; 7 71 7 72 /* structure for the set_break_table and get_break_table 7 73* control orders */ 7 74 7 75 declare break_table_ptr pointer; 7 76 declare 1 break_table_info aligned based (break_table_ptr), 7 77 2 version fixed bin, 7 78 2 breaks (0:127) bit (1) unaligned; 7 79 7 80 declare (break_table_info_version, break_table_info_version_1) 7 81 fixed bin init (1) internal static options (constant); 7 82 7 83 declare 1 more_handler_info aligned based (more_handler_info_ptr), 7 84 2 version fixed bin, 7 85 2 flags unaligned, 7 86 3 old_handler_valid 7 87 bit(1), 7 88 3 pad bit(35), 7 89 2 more_handler entry (pointer, bit(1) aligned), 7 90 2 old_more_handler entry (pointer, bit(1) aligned); 7 91 7 92 declare more_handler_info_ptr pointer; 7 93 7 94 declare (more_handler_info_version, more_handler_info_version_3) 7 95 fixed bin internal static options (constant) init (3); 7 96 7 97 declare 1 token_characters_info aligned based (token_characters_info_ptr), 7 98 2 version char(8), 7 99 2 token_character_count 7 100 fixed bin, 7 101 2 token_characters 7 102 char (128) unaligned; 7 103 7 104 declare token_characters_info_ptr pointer; 7 105 7 106 declare token_characters_info_version_1 char(8) internal static options (constant) init ("wtci0001"); 7 107 7 108 declare 1 more_prompt_info aligned based (more_prompt_info_ptr), 7 109 2 version char(8), 7 110 2 more_prompt char(80); 7 111 7 112 declare more_prompt_info_ptr pointer; 7 113 7 114 declare more_prompt_info_version_1 char(8) static options (constant) init ("wsmp0001"); 7 115 7 116 /* Line editor stuff ... */ 7 117 7 118 dcl line_editor_key_binding_info_ptr 7 119 pointer; 7 120 7 121 dcl line_editor_binding_count 7 122 fixed bin; 7 123 dcl line_editor_longest_sequence 7 124 fixed bin; 7 125 /* For each binding, action defines what to do for that sequence. Constants 7 126* are defined in window_editor_values.incl.pl1. Only if action is set to 7 127* EXTERNAL_ROUTINE does the editor_routine entry variable get examined. */ 7 128 7 129 dcl 1 line_editor_key_binding_info 7 130 aligned based (line_editor_key_binding_info_ptr), 7 131 2 version char(8), 7 132 2 binding_count fixed bin, 7 133 2 longest_sequence fixed bin, 7 134 2 bindings (line_editor_binding_count refer 7 135 (line_editor_key_binding_info.binding_count)), 7 136 3 sequence char(line_editor_longest_sequence refer 7 137 (line_editor_key_binding_info.longest_sequence)) varying, 7 138 3 action fixed bin, 7 139 3 numarg_action fixed binary, 7 140 3 editor_routine entry (pointer, fixed bin(35)), 7 141 3 name char (64) varying unaligned, 7 142 3 description char (256) varying unaligned, 7 143 3 info_path unaligned, 7 144 4 info_dir char (168), 7 145 4 info_entry char (32); 7 146 7 147 7 148 dcl line_editor_key_binding_info_version_3 7 149 char(8) static options (constant) init ("lekbi003"); 7 150 7 151 dcl 1 get_editor_key_bindings_info aligned based (get_editor_key_bindings_info_ptr), 7 152 2 version char (8), 7 153 2 flags, 7 154 3 entire_state bit (1) unaligned, 7 155 3 mbz bit (35) unaligned, 7 156 2 key_binding_info_ptr ptr, 7 157 2 entire_state_ptr ptr; 7 158 7 159 dcl get_editor_key_bindings_info_ptr ptr; 7 160 dcl get_editor_key_bindings_info_version_1 char (8) int static options (constant) init ("gekbi_01"); 7 161 7 162 dcl 1 set_editor_key_bindings_info aligned 7 163 based (set_editor_key_bindings_info_ptr), 7 164 2 version char (8), 7 165 2 flags, 7 166 3 replace bit (1) unaligned, 7 167 3 update bit (1) unaligned, 7 168 3 mbz bit (34) unaligned, 7 169 2 key_binding_info_ptr ptr; 7 170 7 171 dcl set_editor_key_bindings_info_ptr ptr; 7 172 dcl set_editor_key_bindings_info_version_1 char (8) int static options (constant) init ("sekbi_01"); 7 173 7 174 /* This should be moved to window_info.incl.pl1 when that include file is 7 175* created. JR 2/1/84 */ 7 176 7 177 dcl 1 window_edit_line_info 7 178 based (window_edit_line_info_ptr), 7 179 2 version char (8), 7 180 2 line_ptr ptr, 7 181 2 line_length fixed bin (21); /* later we will hack initial cursor position, key bindings, etc. */ 7 182 7 183 dcl window_edit_line_info_version_1 7 184 char (8) static options (constant) init ("wedl0001"); 7 185 7 186 dcl window_edit_line_info_ptr 7 187 ptr; 7 188 7 189 /* END INCLUDE FILE window_control_info.incl.pl1 */ 3431 3432 8 1 /* Begin include file more_info.incl.pl1 WMY January 1982 */ 8 2 8 3 declare more_info_ptr pointer; 8 4 8 5 declare 1 more_info aligned based (more_info_ptr), 8 6 2 version fixed bin, 8 7 2 more_mode fixed bin, /* which flavor */ 8 8 2 window_iocb_ptr pointer, /* for window that MORE'd */ 8 9 2 more_prompt character (80), /* "MORE?" */ 8 10 2 more_responses, 8 11 3 n_yeses fixed bin, /* number valid */ 8 12 3 n_noes fixed bin, 8 13 3 more_yeses character (32) unaligned, /* at most 32 yeses */ 8 14 3 more_noes character (32) unaligned; 8 15 8 16 declare (more_info_version, more_info_version_2) fixed bin static options (constant) init (2); 8 17 8 18 /* End include file window_more_info.incl.pl1 */ 3433 3434 9 1 /* Begin include file tc_screen_image.incl.pl1 BIM Sept 81 */ 9 2 /* format: style3 */ 9 3 9 4 declare 1 screen aligned based (screen_ptr), 9 5 2 n_lines fixed bin, 9 6 2 n_columns fixed bin, 9 7 2 is_clear bit (1) aligned, /* opt */ 9 8 2 lines (screen_n_lines refer (screen.n_lines)) 9 9 character (screen_n_columns refer (screen.n_columns)) unaligned; 9 10 9 11 9 12 declare screen_ptr pointer; 9 13 declare (screen_n_lines, screen_n_columns) 9 14 fixed bin; 9 15 9 16 /* End include file tc_screen_image.incl.pl1 */ 3435 3436 10 1 /* BEGIN INCLUDE FILE ... tty_convert.incl.pl1 */ 10 2 10 3 /* tty_ conversion tables */ 10 4 /* Created 11/3/75 by Robert S. Coren */ 10 5 /* Info structures added 5/19/77 by Robert S. Coren */ 10 6 /* Length of cv_trans changed from 128 to 256 05/03/78 by Robert Coren */ 10 7 /* conversion table mnemonics added JRDavis 21 Aug 80 */ 10 8 /* fix special_chars_struc to have good refers Fri 13 Feb 81 JRDavis */ 10 9 10 10 10 11 /****^ HISTORY COMMENTS: 10 12* 1) change(85-12-01,Negaret), approve(87-07-23,MCR7742), 10 13* audit(87-07-23,GDixon), install(87-08-04,MR12.1-1056): 10 14* Added INPUT_CONVERT_DSA_CR_PROCESSING constant. 10 15* 2) change(88-01-22,Brunelle), approve(88-01-22,MCR7813), 10 16* audit(88-10-05,Blair), install(88-10-17,MR12.2-1171): 10 17* Expand c_chars definition from 3 chars to 15. Change SPECIAL_VERSION 10 18* from 1 to 2. Add version variable to get_special_info_struc and define 10 19* SPECIAL_INFO_STRUCT_VERSION_1. 10 20* END HISTORY COMMENTS */ 10 21 10 22 10 23 /* format: style2,linecom,^indnoniterdo,indcomtxt,^inditerdo,dclind5,idind25 */ 10 24 10 25 10 26 dcl 1 special_chars aligned based, /* table of special character sequences */ 10 27 2 nl_seq aligned like c_chars, /* new-line sequence */ 10 28 2 cr_seq aligned like c_chars, /* carriage-return sequence */ 10 29 2 bs_seq aligned like c_chars, /* backspace sequence */ 10 30 2 tab_seq aligned like c_chars, /* horizontal tab sequence */ 10 31 2 vt_seq aligned like c_chars, /* vertical tab sequence */ 10 32 2 ff_seq aligned like c_chars, /* form-feed sequence */ 10 33 2 printer_on aligned like c_chars, /* printer-on sequence */ 10 34 2 printer_off aligned like c_chars, /* printer_off sequence */ 10 35 2 red_ribbon_shift aligned like c_chars, /* red ribbon shift sequence */ 10 36 2 black_ribbon_shift aligned like c_chars, /* black ribbon shift sequence */ 10 37 2 end_of_page aligned like c_chars, /* end-of-page warning sequence */ 10 38 2 escape_length fixed bin, /* number of escape sequences */ 10 39 2 not_edited_escapes (sc_escape_len refer (special_chars.escape_length)) like c_chars, 10 40 /* use in ^edited mode */ 10 41 2 edited_escapes (sc_escape_len refer (special_chars.escape_length)) like c_chars, 10 42 /* use in edited mode */ 10 43 2 input_escapes aligned, 10 44 3 len fixed bin (8) unaligned, /* length of string */ 10 45 3 str char (sc_input_escape_len refer (special_chars.input_escapes.len)) unaligned, 10 46 /* escape sequence characters */ 10 47 2 input_results aligned, 10 48 3 pad bit (9) unaligned, /* so that strings will look the same */ 10 49 3 str char (sc_input_escape_len refer (special_chars.input_escapes.len)) unaligned; 10 50 /* results of escape sequences */ 10 51 10 52 10 53 dcl c_chars_ptr ptr; 10 54 dcl 1 c_chars based (c_chars_ptr) aligned, 10 55 2 count fixed bin (8) unaligned, 10 56 2 chars (15) char (1) unaligned; 10 57 10 58 dcl sc_escape_len fixed bin; /* count of output escapes to allocate in special_chars */ 10 59 dcl sc_input_escape_len fixed bin; /* count of input escapes to allocate in special_chars */ 10 60 10 61 10 62 dcl 1 cv_trans based aligned, /* conversion/translation table format */ 10 63 2 value (0:255) fixed bin (8) unal; 10 64 10 65 10 66 dcl 1 delay based aligned, /* delay counts for output */ 10 67 2 vert_nl fixed bin, 10 68 2 horz_nl float bin, 10 69 2 const_tab fixed bin, 10 70 2 var_tab float bin, 10 71 2 backspace fixed bin, 10 72 2 vt_ff fixed bin; 10 73 10 74 /* info structures used with orders */ 10 75 10 76 dcl 1 special_chars_struc aligned based, 10 77 2 version fixed bin, 10 78 2 default fixed bin, /* non-zero indicates use default */ 10 79 2 special_chars, /* same as level-1 above */ 10 80 /* has to be spelled out instead of using like */ 10 81 /* because of refer options */ 10 82 3 nl_seq aligned like c_chars, /* new-line sequence */ 10 83 3 cr_seq aligned like c_chars, /* carriage-return sequence */ 10 84 3 bs_seq aligned like c_chars, /* backspace sequence */ 10 85 3 tab_seq aligned like c_chars, /* horizontal tab sequence */ 10 86 3 vt_seq aligned like c_chars, /* vertical tab sequence */ 10 87 3 ff_seq aligned like c_chars, /* form-feed sequence */ 10 88 3 printer_on aligned like c_chars, /* printer-on sequence */ 10 89 3 printer_off aligned like c_chars, /* printer_off sequence */ 10 90 3 red_ribbon_shift aligned like c_chars, /* red ribbon shift sequence */ 10 91 3 black_ribbon_shift aligned like c_chars, /* black ribbon shift sequence */ 10 92 3 end_of_page aligned like c_chars, /* end-of-page warning sequence */ 10 93 3 escape_length fixed bin, /* number of escape sequences */ 10 94 3 not_edited_escapes (sc_escape_len refer (special_chars_struc.escape_length)) like c_chars, 10 95 /* use in ^edited mode */ 10 96 3 edited_escapes (sc_escape_len refer (special_chars_struc.escape_length)) like c_chars, 10 97 /* use in edited mode */ 10 98 3 input_escapes aligned, 10 99 4 len fixed bin (8) unaligned, /* length of string */ 10 100 4 str char (sc_input_escape_len refer (special_chars_struc.input_escapes.len)) unaligned, 10 101 /* escape sequence characters */ 10 102 3 input_results aligned, 10 103 4 pad bit (9) unaligned, /* so that strings will look the same */ 10 104 4 str char (sc_input_escape_len refer (special_chars_struc.input_escapes.len)) unaligned; 10 105 /* results of escape sequences */ 10 106 10 107 dcl 1 cv_trans_struc aligned based, /* all conversion/translation tables */ 10 108 2 version fixed bin, 10 109 2 default fixed bin, /* as above */ 10 110 2 cv_trans like cv_trans; 10 111 10 112 dcl 1 delay_struc aligned based, 10 113 2 version fixed bin, 10 114 2 default fixed bin, /* as above */ 10 115 2 delay like delay; 10 116 10 117 dcl 1 get_special_info_struc based aligned, /* get_special order */ 10 118 2 version char (8), 10 119 2 area_ptr pointer, 10 120 2 table_ptr pointer; 10 121 10 122 dcl SPECIAL_INFO_STRUCT_VERSION_1 10 123 char (8) int static options (constant) init ("sisv1000"); 10 124 dcl SPECIAL_VERSION fixed bin int static options (constant) init (1); 10 125 dcl SPECIAL_VERSION_2 fixed bin int static options (constant) init (2); 10 126 dcl DELAY_VERSION fixed bin int static options (constant) init (1); 10 127 dcl CV_TRANS_VERSION fixed bin int static options (constant) init (2); 10 128 10 129 dcl CV_TRANS_SIZE (2) fixed bin int static options (constant) init (127, 255); 10 130 /* indexed by version number */ 10 131 10 132 10 133 /* values for input and output conversion tables */ 10 134 10 135 dcl ( 10 136 INPUT_CONVERT_ORDINARY init (0), 10 137 INPUT_CONVERT_BREAK init (1), 10 138 INPUT_CONVERT_ESCAPE init (2), 10 139 INPUT_CONVERT_DISCARD init (3), 10 140 INPUT_CONVERT_FORMFEED init (4), 10 141 INPUT_CONVERT_PRECEDENCE_DISCARD 10 142 init (5), 10 143 INPUT_CONVERT_DSA_CR_PROCESSING 10 144 init (6) 10 145 ) fixed bin (8) unaligned internal static options (constant); 10 146 10 147 dcl ( 10 148 OUTPUT_CONVERT_ORDINARY init (0), 10 149 OUTPUT_CONVERT_NEWLINE init (1), 10 150 OUTPUT_CONVERT_CR init (2), 10 151 OUTPUT_CONVERT_HT init (3), 10 152 OUTPUT_CONVERT_BS init (4), 10 153 OUTPUT_CONVERT_VT init (5), 10 154 OUTPUT_CONVERT_FF init (6), 10 155 OUTPUT_CONVERT_OCTAL init (7), 10 156 OUTPUT_CONVERT_RRS init (8), 10 157 OUTPUT_CONVERT_BRS init (9), 10 158 OUTPUT_CONVERT_NO_MOTION init (10), 10 159 OUTPUT_CONVERT_PRECEDENCE_NO_MOTION 10 160 init (11), 10 161 OUTPUT_CONVERT_DONT_SEND init (12), 10 162 OUTPUT_CONVERT_NOT_USED_13 10 163 init (13), 10 164 OUTPUT_CONVERT_NOT_USED_14 10 165 init (14), 10 166 OUTPUT_CONVERT_NOT_USED_15 10 167 init (15), 10 168 OUTPUT_CONVERT_NOT_USED_16 10 169 init (16), 10 170 OUTPUT_CONVERT_FIRST_SPECIAL 10 171 init (17) 10 172 ) fixed bin (8) unaligned internal static options (constant); 10 173 10 174 /* END INCLUDE FILE ... tty_convert.incl.pl1 */ 3437 3438 11 1 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 11 2 11 3 /* Written 05/04/78 by C. D. Tavares */ 11 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 11 5 /* Modified 5/83 by S. Krupp to add declarations for: iox_$open_file, 11 6* iox_$close_file, iox_$detach and iox_$attach_loud entries. */ 11 7 11 8 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 11 9 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 11 10 iox_$close entry (pointer, fixed bin (35)), 11 11 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 11 12 iox_$delete_record entry (pointer, fixed bin (35)), 11 13 iox_$destroy_iocb entry (pointer, fixed bin (35)), 11 14 iox_$detach_iocb entry (pointer, fixed bin (35)), 11 15 iox_$err_not_attached entry options (variable), 11 16 iox_$err_not_closed entry options (variable), 11 17 iox_$err_no_operation entry options (variable), 11 18 iox_$err_not_open entry options (variable), 11 19 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 11 20 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 11 21 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 11 22 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 11 23 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 11 24 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 11 25 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 11 26 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 11 27 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 11 28 iox_$propagate entry (pointer), 11 29 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 11 30 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 11 31 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 11 32 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 11 33 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 11 34 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 11 35 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 11 36 iox_$open_file entry(ptr, fixed bin, char(*), bit(1) aligned, fixed bin(35)), 11 37 iox_$close_file entry(ptr, char(*), fixed bin(35)), 11 38 iox_$detach entry(ptr, char(*), fixed bin(35)), 11 39 iox_$attach_loud entry(ptr, char(*), ptr, fixed bin(35)); 11 40 11 41 dcl (iox_$user_output, 11 42 iox_$user_input, 11 43 iox_$user_io, 11 44 iox_$error_output) external static pointer; 11 45 11 46 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 3439 3440 12 1 /* BEGIN INCLUDE FILE ..... iocb.incl.pl1 ..... 13 Feb 1975, M. Asherman */ 12 2 /* Modified 11/29/82 by S. Krupp to add new entries and to change 12 3* version number to IOX2. */ 12 4 /* format: style2 */ 12 5 12 6 dcl 1 iocb aligned based, /* I/O control block. */ 12 7 2 version character (4) aligned, /* IOX2 */ 12 8 2 name char (32), /* I/O name of this block. */ 12 9 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 12 10 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 12 11 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 12 12 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 12 13 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 12 14 2 reserved bit (72), /* Reserved for future use. */ 12 15 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 12 16 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 12 17 /* open(p,mode,not_used,s) */ 12 18 2 close entry (ptr, fixed (35)),/* close(p,s) */ 12 19 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 12 20 /* get_line(p,bufptr,buflen,actlen,s) */ 12 21 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 12 22 /* get_chars(p,bufptr,buflen,actlen,s) */ 12 23 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 12 24 /* put_chars(p,bufptr,buflen,s) */ 12 25 2 modes entry (ptr, char (*), char (*), fixed (35)), 12 26 /* modes(p,newmode,oldmode,s) */ 12 27 2 position entry (ptr, fixed, fixed (21), fixed (35)), 12 28 /* position(p,u1,u2,s) */ 12 29 2 control entry (ptr, char (*), ptr, fixed (35)), 12 30 /* control(p,order,infptr,s) */ 12 31 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 12 32 /* read_record(p,bufptr,buflen,actlen,s) */ 12 33 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 12 34 /* write_record(p,bufptr,buflen,s) */ 12 35 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 12 36 /* rewrite_record(p,bufptr,buflen,s) */ 12 37 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 12 38 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 12 39 /* seek_key(p,key,len,s) */ 12 40 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 12 41 /* read_key(p,key,len,s) */ 12 42 2 read_length entry (ptr, fixed (21), fixed (35)), 12 43 /* read_length(p,len,s) */ 12 44 2 open_file entry (ptr, fixed bin, char (*), bit (1) aligned, fixed bin (35)), 12 45 /* open_file(p,mode,desc,not_used,s) */ 12 46 2 close_file entry (ptr, char (*), fixed bin (35)), 12 47 /* close_file(p,desc,s) */ 12 48 2 detach entry (ptr, char (*), fixed bin (35)); 12 49 /* detach(p,desc,s) */ 12 50 12 51 declare iox_$iocb_version_sentinel 12 52 character (4) aligned external static; 12 53 12 54 /* END INCLUDE FILE ..... iocb.incl.pl1 ..... */ 3441 3442 13 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 13 2 /* format: style3 */ 13 3 13 4 /* These constants are to be used for the flags argument of sub_err_ */ 13 5 /* They are just "string (condition_info_header.action_flags)" */ 13 6 13 7 declare ( 13 8 ACTION_CAN_RESTART init (""b), 13 9 ACTION_CANT_RESTART init ("1"b), 13 10 ACTION_DEFAULT_RESTART 13 11 init ("01"b), 13 12 ACTION_QUIET_RESTART 13 13 init ("001"b), 13 14 ACTION_SUPPORT_SIGNAL 13 15 init ("0001"b) 13 16 ) bit (36) aligned internal static options (constant); 13 17 13 18 /* End include file */ 3443 3444 3445 end window_io_iox_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/17/88 1025.5 window_io_iox_.pl1 >spec>install>MR12.2-1171>window_io_iox_.pl1 3425 1 07/24/86 2051.7 window_io_attach_data_.incl.pl1 >ldd>include>window_io_attach_data_.incl.pl1 1-168 2 09/12/84 0916.7 window_editor_values.incl.pl1 >ldd>include>window_editor_values.incl.pl1 1-169 3 09/12/84 0916.7 window_status.incl.pl1 >ldd>include>window_status.incl.pl1 1-170 4 03/27/82 0429.7 terminal_capabilities.incl.pl1 >ldd>include>terminal_capabilities.incl.pl1 3427 5 09/12/84 0916.7 window_line_editor.incl.pl1 >ldd>include>window_line_editor.incl.pl1 3429 6 09/12/84 0916.7 window_dcls.incl.pl1 >ldd>include>window_dcls.incl.pl1 3431 7 09/12/84 0916.7 window_control_info.incl.pl1 >ldd>include>window_control_info.incl.pl1 3433 8 06/10/82 1045.5 window_more_info.incl.pl1 >ldd>include>window_more_info.incl.pl1 3435 9 03/27/82 0424.8 tc_screen_image.incl.pl1 >ldd>include>tc_screen_image.incl.pl1 3437 10 10/17/88 1024.1 tty_convert.incl.pl1 >spec>install>MR12.2-1171>tty_convert.incl.pl1 3439 11 05/23/83 0916.6 iox_entries.incl.pl1 >ldd>include>iox_dcls.incl.pl1 3441 12 05/20/83 1846.4 iocb.incl.pl1 >ldd>include>iocb.incl.pl1 3443 13 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.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. ACTION_CANT_RESTART constant bit(36) initial dcl 13-7 ref 2958 ACTION_DEFAULT_RESTART constant bit(36) initial dcl 13-7 ref 2960 ASYNC_EVENT 000414 automatic label variable local dcl 147 set ref 444* 2933 2946 2966 3334* 3340* 3420 BACKWARD_CHARACTER constant fixed bin(17,0) initial dcl 2-13 ref 214 BACKWARD_DELETE_CHARACTER constant fixed bin(17,0) initial dcl 2-13 ref 219 236 240 BACKWARD_DELETE_WORD constant fixed bin(17,0) initial dcl 2-13 ref 292 293 BACKWARD_KILL 000125 constant bit(1) initial dcl 158 set ref 1159* 1708* BACKWARD_WORD constant fixed bin(17,0) initial dcl 2-13 ref 273 282 BELL 020440 constant char(1) initial packed unaligned dcl 162 ref 1403 2644 BREAKS_CHANGED 000406 automatic bit(1) packed unaligned dcl 145 set ref 429* 528 532* 648* 655* Buffer based char packed unaligned dcl 107 set ref 376* 492* 3336* 3351* 3360 3362 3362 3362 3362 3394* Buffer_len parameter fixed bin(21,0) dcl 92 ref 328 348 367 375 376 379 490 492 3320 3336 3336 3351 3351 3360 3362 3362 3367 3379 3394 Buffer_ptr parameter pointer dcl 91 ref 328 348 367 376 492 3320 3336 3351 3360 3362 3362 3367 3379 3394 CLEAR_WINDOW constant fixed bin(17,0) initial dcl 2-13 ref 226 CONTINUATION_CHARS 000077 constant char(2) initial packed unaligned dcl 156 set ref 2229 2240 2258 2262 2274 2286 2703 2703 2703 2703 2706 Code parameter fixed bin(35,0) dcl 93 set ref 328 337* 342* 348 357* 381* 414* 415 466* 502* 3305* 3320 3326* 3367 3370* 3384* 3385 3401* 3402 DEL constant char(1) initial packed unaligned dcl 161 ref 731 DISPLAY_EDITOR_DOCUMENTATION constant fixed bin(17,0) initial dcl 2-13 ref 234 291 ERROR_COUNT 000420 automatic fixed bin(17,0) dcl 148 set ref 428* 2958 2962* 2962 3327* FORWARD_CHARACTER constant fixed bin(17,0) initial dcl 2-13 ref 218 FORWARD_DELETE_CHARACTER constant fixed bin(17,0) initial dcl 2-13 ref 215 FORWARD_DELETE_WORD constant fixed bin(17,0) initial dcl 2-13 ref 275 284 FORWARD_KILL 000131 constant bit(1) initial dcl 157 set ref 484* 1238* 1688* 2799 FORWARD_WORD constant fixed bin(17,0) initial dcl 2-13 ref 276 285 IGNORE constant fixed bin(17,0) initial dcl 2-143 ref 830 835 840 845 875 880 885 895 900 905 910 915 990 INITIAL_CAPITAL constant fixed bin(17,0) initial dcl 2-13 ref 274 283 Iocb_ptr parameter pointer dcl 90 ref 192 192 196 300 303 328 348 353 3310 3313 3320 3323 3367 3373 KILL_RING_SIZE constant fixed bin(17,0) initial dcl 2757 ref 2780 KILL_TO_BEGINNING_OF_LINE constant fixed bin(17,0) initial dcl 2-13 ref 239 KILL_TO_END_OF_LINE constant fixed bin(17,0) initial dcl 2-13 ref 224 LEI based structure level 1 dcl 2114 in procedure "delete_from_buffer" LEI based structure level 1 dcl 1678 in procedure "forward_delete_word" LEI based structure level 1 dcl 1300 in procedure "quote_character" LEI based structure level 1 dcl 1325 in procedure "yank_from_kill_ring" LEI based structure level 1 dcl 1152 in procedure "kill_to_beginning_of_line" LEI based structure level 1 unaligned dcl 2761 in procedure "add_to_kill_ring" LEI based structure level 1 dcl 1339 in procedure "process_input_escape" LEI based structure level 1 unaligned dcl 1970 in procedure "get_current_word_info" LEI based structure level 1 dcl 131 in procedure "window_io_iox_" LEI based structure level 1 dcl 1235 in procedure "kill_to_end_of_line" LEI based structure level 1 dcl 1198 in procedure "move_to_beginning_of_line" LEI based structure level 1 dcl 1248 in procedure "twiddle_characters" LEI based structure level 1 unaligned dcl 1776 in procedure "lowercase_word" LEI based structure level 1 dcl 719 in procedure "process_break" LEI based structure level 1 unaligned dcl 1843 in procedure "initial_capital" LEI based structure level 1 dcl 1184 in procedure "forward_character" LEI based structure level 1 dcl 1597 in procedure "negative_number_reader" LEI based structure level 1 dcl 2015 in procedure "move_forward_word" LEI based structure level 1 dcl 1119 in procedure "self_insert" LEI based structure level 1 dcl 1578 in procedure "multiplier" LEI based structure level 1 dcl 1268 in procedure "terminate_input_line" LEI based structure level 1 dcl 1718 in procedure "yank_previous_from_kill_ring" LEI based structure level 1 unaligned dcl 1901 in procedure "twiddle_words" LEI based structure level 1 dcl 1211 in procedure "move_to_end_of_line" LEI based structure level 1 dcl 2082 in procedure "insert_in_buffer" LEI based structure level 1 dcl 1699 in procedure "backward_delete_word" LEI based structure level 1 dcl 1616 in procedure "read_numbers_then_dispatch" LEI based structure level 1 dcl 612 in procedure "read_input_line" LEI based structure level 1 dcl 2049 in procedure "move_backward_word" LEI based structure level 1 dcl 1170 in procedure "backward_character" LEI based structure level 1 dcl 1135 in procedure "backward_delete_character" LEUDH based structure level 1 dcl 562 LOWERCASE_WORD constant fixed bin(17,0) initial dcl 2-13 ref 277 286 MORE_MODE_FOLD constant fixed bin(17,0) initial dcl 1-106 ref 2651 3074 3226 3256 MORE_MODE_SCROLL constant fixed bin(17,0) initial dcl 1-106 ref 2233 2251 2651 3074 3220 3249 MORE_MODE_WRAP constant fixed bin(17,0) initial dcl 1-106 ref 2550 3232 3265 MOVE_TO_BEGINNING_OF_LINE constant fixed bin(17,0) initial dcl 2-13 ref 212 MOVE_TO_END_OF_LINE constant fixed bin(17,0) initial dcl 2-13 ref 217 MULTIPLIER constant fixed bin(17,0) initial dcl 2-13 ref 231 NEGATIVE_NUMBER_READER constant fixed bin(17,0) initial dcl 2-13 ref 271 NL 000076 constant char(1) initial packed unaligned dcl 159 set ref 479 1276* NUMBER_READER_0 constant fixed bin(17,0) initial dcl 2-13 ref 261 NUMBER_READER_1 constant fixed bin(17,0) initial dcl 2-13 ref 262 NUMBER_READER_2 constant fixed bin(17,0) initial dcl 2-13 ref 263 NUMBER_READER_3 constant fixed bin(17,0) initial dcl 2-13 ref 264 NUMBER_READER_4 constant fixed bin(17,0) initial dcl 2-13 ref 265 NUMBER_READER_5 constant fixed bin(17,0) initial dcl 2-13 ref 266 NUMBER_READER_6 constant fixed bin(17,0) initial dcl 2-13 ref 267 NUMBER_READER_7 constant fixed bin(17,0) initial dcl 2-13 ref 268 NUMBER_READER_8 constant fixed bin(17,0) initial dcl 2-13 ref 269 NUMBER_READER_9 constant fixed bin(17,0) initial dcl 2-13 ref 270 N_returned parameter fixed bin(21,0) dcl 94 set ref 328 348 358* 375* 376 376 380 490* 492 492 493 501 3367 3371* 3390* OUTPUT_CONVERT_BRS constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2384 2496 2664 OUTPUT_CONVERT_BS constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2454 OUTPUT_CONVERT_CR constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2454 2640 OUTPUT_CONVERT_FF constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2648 OUTPUT_CONVERT_FIRST_SPECIAL constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2501 2501 2507 OUTPUT_CONVERT_HT constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2449 OUTPUT_CONVERT_NEWLINE constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2613 2634 OUTPUT_CONVERT_OCTAL constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2384 2454 OUTPUT_CONVERT_ORDINARY constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2486 OUTPUT_CONVERT_RRS constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2384 2491 2664 OUTPUT_CONVERT_VT constant fixed bin(8,0) initial packed unaligned dcl 10-147 ref 2648 PASS constant fixed bin(17,0) initial dcl 2-143 ref 870 920 925 930 935 940 945 950 955 960 965 970 975 980 985 995 PROCESSED_SO_FAR 000421 automatic fixed bin(17,0) dcl 149 set ref 2595* 2598 2601 2603 2607 2614 2621* 2621 2626* 2626 3328* 3360 3362 3362 PROCESS_INPUT_ESCAPE constant fixed bin(17,0) initial dcl 2-13 ref 241 QUOTE_CHARACTER constant fixed bin(17,0) initial dcl 2-13 ref 229 REAL_CL_INTERMEDIARY 000402 automatic entry variable dcl 144 set ref 431* 449* 525 525* 3418 REJECT constant fixed bin(17,0) initial dcl 2-143 ref 771 REPEAT constant fixed bin(17,0) initial dcl 2-143 ref 763 768 810 815 820 825 850 855 860 865 890 SAVED_BREAKS 000407 automatic bit(128) packed unaligned dcl 146 set ref 430* 530 649* 654 SELF_INSERT constant fixed bin(17,0) initial dcl 2-13 ref 209 221 TEN_SPACES 020441 constant char(10) initial packed unaligned dcl 155 ref 2451 TERMINATE_INPUT_LINE constant fixed bin(17,0) initial dcl 2-13 ref 222 227 TWIDDLE_CHARACTERS constant fixed bin(17,0) initial dcl 2-13 ref 230 TWIDDLE_WORDS constant fixed bin(17,0) initial dcl 2-13 ref 278 287 UNDEFINED constant fixed bin(17,0) initial dcl 2-13 ref 204 205 252 UPPERCASE_WORD constant fixed bin(17,0) initial dcl 2-13 ref 279 288 WINDOW_LINE_USED based bit(1) array packed unaligned dcl 127 set ref 439 522 589* 1999* 2166* 2209* 2212 2214* 2223* 2241* 2260* 2305* 2305 Window_edit_line_info_ptr parameter pointer dcl 331 ref 328 334 YANK_FROM_KILL_RING constant fixed bin(17,0) initial dcl 2-13 ref 232 YANK_PREVIOUS_FROM_KILL_RING constant fixed bin(17,0) initial dcl 2-13 ref 280 289 a_code parameter fixed bin(35,0) dcl 102 set ref 1002 1007* 1010 1015* 1018 1023* 1026 1029* 1032* 1038 1041* 1044* 1050 1055* 1058 1063* 1066 1074 1096* 1101* a_count parameter fixed bin(21,0) dcl 99 set ref 1010 1015* 1018 1023* 1026 1032 1034 1038 1044 1046 a_kill_direction parameter bit(1) dcl 100 set ref 1018 1023* a_lei_ptr parameter pointer dcl 98 set ref 1002 1007* 1010 1015* 1018 1023* 1026 1032 1032 1034 1034 1038 1044 1046 1046 1050 1055* 1058 1063* 1066 1074 1095 1100 1105 a_table_ptr parameter pointer dcl 103 ref 313 317 317 321 a_text parameter char packed unaligned dcl 101 set ref 1002 1007* 1066 1071* actual_iocb_ptr 12 based pointer level 2 dcl 12-6 ref 196 303 353 1105 3313 3323 3373 addcharno builtin function dcl 181 ref 2622 2627 2705 addr builtin function dcl 181 ref 391 531 531 2024 2030 2057 2063 2594 2678 2678 2703 2703 2889 2896 2986 2986 3015 3015 3125 3125 3401 3401 army 166 based pointer level 3 dcl 1-29 set ref 2845 2846* 2874 2875* attach_data based structure level 1 dcl 1-29 attach_data_area based area(1024) dcl 1-113 ref 2858 2886 2903 attach_data_ptr 16 based pointer level 2 in structure "iocb" dcl 12-6 in procedure "window_io_iox_" ref 197 304 355 1107 3314 3324 3374 attach_data_ptr 000430 automatic pointer dcl 1-28 in procedure "window_io_iox_" set ref 197* 199 239 240 241 246 293 304* 306 308 308 355* 361 365 374 375 376 379 380 380 384 385 425 426 430 439 456 456 457 458 462 462 484 499 501 506 522 543 549 550 580 583 584 584 584 584 584 584 584 589 624 624 628 629 645 649 650 650 654 723 1071 1107* 1328 1354 1411 1411 1411 1424 1425 1431 1431 1723 1723 1723 1723 1726 1727 1727 1732 1751 1759 1760 1998 1998 1998 1998 1998 1999 2024 2024 2030 2030 2057 2057 2063 2063 2165 2165 2165 2165 2195 2204 2208 2208 2208 2208 2211 2213 2213 2213 2213 2222 2222 2222 2222 2233 2233 2236 2240 2240 2240 2240 2244 2251 2251 2254 2258 2258 2258 2258 2265 2265 2265 2265 2265 2282 2282 2286 2290 2303 2304 2304 2304 2304 2304 2304 2304 2304 2308 2422 2433 2471 2475 2491 2496 2501 2501 2507 2535 2535 2537 2537 2538 2546 2548 2553 2596 2596 2630 2636 2648 2651 2651 2653 2653 2658 2664 2666 2667 2706 2763 2768 2776 2789 2795 2795 2799 2799 2801 2801 2810 2810 2822 2824 2825 2825 2828 2829 2830 2831 2831 2833 2845 2846 2874 2875 2885 2887 2889 2889 2892 2893 2896 2896 2899 2900 2903 2904 2924 2924 2927 2928 2931 2958 2986 2991 2992 2993 2994 2999 2999 2999 3005 3010 3010 3010 3038 3039 3040 3070 3074 3074 3074 3074 3079 3079 3079 3105 3110 3111 3112 3113 3114 3115 3120 3125 3130 3131 3144 3145 3145 3150 3151 3151 3155 3162 3170 3170 3182 3183 3197 3198 3200 3203 3220 3222 3226 3227 3232 3233 3242 3249 3251 3256 3257 3265 3266 3276 3304 3314* 3316 3324* 3330 3333 3344 3344 3346 3374* 3376 3377 3399 auto_capabilities_info 000105 automatic structure level 1 dcl 2979 set ref 2986 2986 auto_window_position_info 000100 automatic structure level 1 dcl 2977 set ref 3015 3015 automatic_line_editor_info 000126 automatic structure level 1 dcl 133 set ref 391 b 000100 automatic structure level 1 dcl 517 set ref 531 531 bin builtin function dcl 181 ref 3285 3291 black_ribbon_shift 44 based structure level 2 dcl 10-26 set ref 2496* break 000160 automatic varying char(1) dcl 3095 in procedure "perform_more_break" set ref 3173* 3188 3188 break 000100 automatic char(1) packed unaligned dcl 711 in procedure "process_break" set ref 721* 725 731 741* 741 745 746 749* 750 753 753 756 757 786 break_char parameter varying char(1) dcl 709 in procedure "process_break" ref 705 721 break_char 000466 automatic varying char(1) dcl 602 in procedure "read_input_line" set ref 626* 634* 645* 651* 683 686* break_table_info based structure level 1 dcl 7-76 break_table_info_version constant fixed bin(17,0) initial dcl 7-80 ref 529 breaks 1 000100 automatic bit(1) array level 2 in structure "b" packed packed unaligned dcl 517 in procedure "get_line_cleanup" set ref 530* breaks 147 based bit(128) level 2 in structure "attach_data" packed packed unaligned dcl 1-29 in procedure "window_io_iox_" set ref 430 649 650* 654* buffer_chunk defined char packed unaligned dcl 2019 in begin block on line 2017 ref 2024 2030 buffer_chunk defined char packed unaligned dcl 2053 in begin block on line 2051 ref 2057 2063 byte builtin function dcl 181 ref 741 1393 1393 3285 3287 3291 c parameter char(1) packed unaligned dcl 3283 ref 3280 3285 3287 3287 3289 3291 3293 c_chars based structure level 1 dcl 10-54 c_chars_struc parameter structure level 1 dcl 2518 ref 2515 capabilities_info based structure level 1 dcl 4-3 capabilities_info_version_1 constant fixed bin(17,0) initial dcl 4-17 ref 2985 char parameter char(1) packed unaligned dcl 2441 in procedure "convert_char" ref 2438 2473 2488 char parameter char(1) packed unaligned dcl 2431 in procedure "scan_for_interesting_char" ref 2428 2433 char_count parameter fixed bin(21,0) dcl 2751 in procedure "add_to_kill_ring" ref 2746 2759 char_count 000115 automatic fixed bin(17,0) dcl 119 in procedure "window_io_iox_" set ref 3383* 3390 3394* char_index 000136 automatic fixed bin(21,0) dcl 2340 in procedure "perform_output_conversions" set ref 2359* 2364 2366 2372 2380 2381 2388 2388 2392 char_index parameter fixed bin(21,0) dcl 2412 in procedure "scan_for_interesting_char" set ref 2407 2422* char_nonvarying 000114 automatic char(1) packed unaligned dcl 118 set ref 3400* 3401 3401 char_rep 001132 automatic varying char(32) dcl 2587 set ref 2630* 2668 2677 2678 2678 char_rep_length 001153 automatic fixed bin(17,0) dcl 2589 set ref 2630* char_temp 001143 automatic char(32) packed unaligned dcl 2588 set ref 2677* 2678 2678 char_type 000137 automatic fixed bin(17,0) dcl 2341 in procedure "perform_output_conversions" set ref 2359* 2384 2384 2384* 2388* char_type parameter fixed bin(17,0) dcl 2442 in procedure "convert_char" ref 2438 2449 2454 2454 2454 2486 2491 2496 2501 2501 2507 char_type parameter fixed bin(17,0) dcl 2413 in procedure "scan_for_interesting_char" set ref 2407 2424* char_varying 000112 automatic varying char(1) dcl 117 set ref 3384* 3389 3394 3400 chars 0(09) parameter char(1) array level 2 packed packed unaligned dcl 2518 ref 2523 2523 2524 2524 chars_left_to_write 001164 automatic fixed bin(17,0) dcl 2692 set ref 2710* 2711* 2712 chars_returned parameter fixed bin(21,0) dcl 2336 set ref 2329 2348* 2369 2374 2375* 2375 2380 2381* 2381 2388 2388 2391* 2391 2400 chars_seen 000141 automatic fixed bin(21,0) dcl 2343 set ref 2364* 2366* 2369 cl_arg parameter structure level 1 dcl 3411 set ref 3409 3418* cleanup 000422 stack reference condition dcl 151 ref 436 code parameter fixed bin(35,0) dcl 1525 in procedure "number_reader_7" set ref 1521 1527* code parameter fixed bin(35,0) dcl 1610 in procedure "read_numbers_then_dispatch" set ref 1606 1620* 1622* code parameter fixed bin(35,0) dcl 1595 in procedure "negative_number_reader" set ref 1591 1599* 1601* code 000100 automatic fixed bin(35,0) dcl 3025 in procedure "raw_write" set ref 3034* 3035* code parameter fixed bin(35,0) dcl 1896 in procedure "twiddle_words" set ref 1892 1903* 1917* 1918 1922 1928 1938* 1939 1944* 1945 1947* 1948 code parameter fixed bin(35,0) dcl 1120 in procedure "self_insert" set ref 1115 1122* 1123* 1125* code 000474 automatic fixed bin(35,0) dcl 607 in procedure "read_input_line" set ref 634* 635* 645* 651* 659* 671* 673 code 000100 automatic fixed bin(35,0) dcl 3059 in procedure "ring" set ref 3061* 3062* code parameter fixed bin(35,0) dcl 1285 in procedure "clear_window" set ref 1281 1287* code parameter fixed bin(35,0) dcl 1470 in procedure "number_reader_2" set ref 1466 1472* code parameter fixed bin(35,0) dcl 1697 in procedure "backward_delete_word" set ref 1693 1704* 1708* code parameter fixed bin(35,0) dcl 1838 in procedure "initial_capital" set ref 1834 1845* 1861* 1862 code parameter fixed bin(35,0) dcl 2911 in procedure "Error_Detector" set ref 2908 2908 2913 2916 2943 2949 2965* code 000100 automatic fixed bin(35,0) dcl 3048 in procedure "clear_to_end_of_line" set ref 3050* 3051* code parameter fixed bin(35,0) dcl 1665 in procedure "forward_word" set ref 1661 1667* code 000101 automatic fixed bin(35,0) dcl 578 in procedure "initialize_window_image" set ref 580* 581* code parameter fixed bin(35,0) dcl 1233 in procedure "kill_to_end_of_line" set ref 1229 1237* 1238* code parameter fixed bin(35,0) dcl 1222 in procedure "forward_delete_character" set ref 1218 1224* 1225* code parameter fixed bin(35,0) dcl 2112 in procedure "delete_from_buffer" set ref 2106 2122 2127* 2132* code parameter fixed bin(35,0) dcl 1676 in procedure "forward_delete_word" set ref 1672 1683* 1688* code parameter fixed bin(35,0) dcl 1514 in procedure "number_reader_6" set ref 1510 1516* code parameter fixed bin(35,0) dcl 1503 in procedure "number_reader_5" set ref 1499 1505* code parameter fixed bin(35,0) dcl 1770 in procedure "lowercase_word" set ref 1766 1781 1786* code 000116 automatic fixed bin(35,0) dcl 120 in procedure "window_io_iox_" set ref 454* 455 460 462* 463* 465 466 508* 2265* 2266* 2294* 2295* 2308* 2309* 2538* 2540* 2548* 2550 2552* 2553* 2554* 2557* 2559* 2562* 2565* 2656* 2657* 2658* 2659* 2669* 2670* 2726* 2727* 2986* 2987* 3015* 3016* 3125* 3129 3134* 3173* 3180 3186* 3222* 3223* 3227* 3228* 3233* 3234* 3236* 3237* 3244* 3245* 3251* 3252* 3257* 3258* 3260* 3261* 3266* 3267* 3269* 3270* 3346* 3347* code parameter fixed bin(35,0) dcl 1196 in procedure "move_to_beginning_of_line" set ref 1192 1200* code parameter fixed bin(35,0) dcl 1536 in procedure "number_reader_8" set ref 1532 1538* code parameter fixed bin(35,0) dcl 1266 in procedure "terminate_input_line" set ref 1262 1270* 1276* code parameter fixed bin(35,0) dcl 1150 in procedure "kill_to_beginning_of_line" set ref 1146 1156* 1159* code parameter fixed bin(35,0) dcl 1448 in procedure "number_reader_0" set ref 1444 1450* code parameter fixed bin(35,0) dcl 1298 in procedure "quote_character" set ref 1294 1306* 1307* 1308* 1314* code parameter fixed bin(35,0) dcl 1209 in procedure "move_to_end_of_line" set ref 1205 1213* code parameter fixed bin(35,0) dcl 1133 in procedure "backward_delete_character" set ref 1129 1137* 1140* 1142* code parameter fixed bin(35,0) dcl 1576 in procedure "multiplier" set ref 1572 1580* 1586* code parameter fixed bin(35,0) dcl 1182 in procedure "forward_character" set ref 1178 1186* code parameter fixed bin(35,0) dcl 1654 in procedure "backward_word" set ref 1650 1656* code parameter fixed bin(35,0) dcl 1716 in procedure "yank_previous_from_kill_ring" set ref 1712 1720* 1727* 1728 1732* 1736* code parameter fixed bin(35,0) dcl 1246 in procedure "twiddle_characters" set ref 1242 1252* 1258* code parameter fixed bin(35,0) dcl 1323 in procedure "yank_from_kill_ring" set ref 1319 1327* 1328* code parameter fixed bin(35,0) dcl 1481 in procedure "number_reader_3" set ref 1477 1483* code 000104 automatic fixed bin(35,0) dcl 713 in procedure "process_break" set ref 735* 736* 747* 748* 764* 772* 782* 783 799 code parameter fixed bin(35,0) dcl 1168 in procedure "backward_character" set ref 1164 1172* code parameter fixed bin(17,0) dcl 1745 in procedure "display_editor_documentation" ref 1741 code parameter fixed bin(35,0) dcl 1337 in procedure "process_input_escape" set ref 1333 1348* 1354* 1355 1360* 1361* 1366* 1367 1373* 1374* 1378* 1379 1390* 1391 1393* 1394 1404* 1405* 1407* 1415* 1416 1418* 1428* 1429 1431* 1438* code parameter fixed bin(35,0) dcl 1459 in procedure "number_reader_1" set ref 1455 1461* code parameter fixed bin(35,0) dcl 1547 in procedure "number_reader_9" set ref 1543 1549* code parameter fixed bin(35,0) dcl 1558 in procedure "number_reader_common" set ref 1554 1561* 1566* code parameter fixed bin(35,0) dcl 1492 in procedure "number_reader_4" set ref 1488 1494* code parameter fixed bin(35,0) dcl 2080 in procedure "insert_in_buffer" set ref 2075 2086* 2091* col 72 based fixed bin(17,0) level 3 dcl 1-29 ref 426 543 550 624 629 1760 2596 2667 3079 col_at_rawo 74 based fixed bin(17,0) level 3 dcl 1-29 set ref 462* column parameter fixed bin(17,0) dcl 2162 in procedure "add_to_window_image" ref 2157 2165 column 1 000100 automatic fixed bin(17,0) level 3 in structure "auto_window_position_info" dcl 2977 in procedure "resize_window" set ref 2994* column_origin 162 based fixed bin(17,0) level 3 dcl 1-29 ref 584 2994 2999 2999 columns 1 000105 automatic fixed bin(17,0) level 3 in structure "auto_capabilities_info" dcl 2979 in procedure "resize_window" set ref 2999 2999 columns 160 based fixed bin(17,0) level 3 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" ref 584 584 584 584 624 1998 1998 1998 2165 2165 2165 2204 2208 2208 2208 2213 2213 2213 2222 2222 2222 2240 2240 2240 2244 2258 2258 2258 2265 2265 2265 2286 2290 2304 2304 2304 2304 2304 2304 2596 2630 2636 2706 2991 2999 3170 3170 continue_output 000100 automatic bit(1) dcl 3087 set ref 3106* 3125* 3136 3200* 3203* 3213 continue_to_signal_ 000116 constant entry external dcl 3101 ref 3122 3164 conversion_tct_table 206 based char(512) level 2 dcl 1-29 set ref 2422* 2433 converted_cursor 000100 automatic fixed bin(21,0) dcl 2180 set ref 2198* 2201* 2274 2286 converted_cursor_index parameter fixed bin(21,0) dcl 2338 set ref 2329 2346* 2369 2369* 2400 2400* converted_length parameter fixed bin(17,0) dcl 2444 in procedure "convert_char" set ref 2438 2447* 2450* 2451 2481* 2487* 2491* 2496* 2501* 2507* converted_length 000101 automatic fixed bin(21,0) dcl 2181 in procedure "redisplay_input_line" set ref 2197* 2201* 2221 2231 2249 2258 2262 converted_length 000142 automatic fixed bin(17,0) dcl 2344 in procedure "perform_output_conversions" set ref 2388* 2391 copy builtin function dcl 181 ref 2096 copy_count 000100 automatic fixed bin(17,0) dcl 2084 set ref 2094* 2096 2096 count 000104 automatic fixed bin(21,0) dcl 1343 in procedure "process_input_escape" set ref 1372* 1388* 1390* count 000100 automatic fixed bin(21,0) dcl 1701 in procedure "backward_delete_word" set ref 1707* 1708* count 000100 automatic fixed bin(21,0) dcl 1680 in procedure "forward_delete_word" set ref 1686* 1688* count parameter fixed bin(8,0) level 2 in structure "c_chars_struc" packed packed unaligned dcl 2518 in procedure "convert_special_sequence" ref 2521 cu_$get_cl_intermediary 000030 constant entry external dcl 187 ref 449 cu_$set_cl_intermediary 000032 constant entry external dcl 189 ref 450 525 current 157 based structure level 2 dcl 1-29 current_hpos parameter fixed bin(17,0) dcl 2443 ref 2438 2450 current_killer 000102 automatic pointer dcl 2755 set ref 2763* 2774* 2774 2776 2777* 2777 2781* 2781 2782* cursor_column 000105 automatic fixed bin(17,0) dcl 2185 set ref 2270* 2286* 2290 2290* 2294* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1184 in procedure "forward_character" set ref 1187 1187* 1187 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1248 in procedure "twiddle_characters" ref 1253 1254 1255 1255 1256 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1699 in procedure "backward_delete_word" ref 1705 1707 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 2114 in procedure "delete_from_buffer" set ref 2132 2135* 2138 2139 2139 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1170 in procedure "backward_character" set ref 1173 1173* 1173 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1268 in procedure "terminate_input_line" set ref 1274* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1211 in procedure "move_to_end_of_line" set ref 1214* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1152 in procedure "kill_to_beginning_of_line" set ref 1157 1158* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 719 in procedure "process_break" set ref 792 792* 794 794* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1198 in procedure "move_to_beginning_of_line" set ref 1201* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1776 in procedure "lowercase_word" ref 1815 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1901 in procedure "twiddle_words" set ref 1915 1925 1931 1937* 1943* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1339 in procedure "process_input_escape" set ref 1351 1388 1389* 1406* 1414* 1427* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 2049 in procedure "move_backward_word" set ref 2053 2065* 2067* 2067 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1135 in procedure "backward_delete_character" set ref 1138 1139* 1139 cursor_index parameter fixed bin(21,0) dcl 2337 in procedure "perform_output_conversions" ref 2329 2369 2369 2369 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 612 in procedure "read_input_line" ref 645 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1718 in procedure "yank_previous_from_kill_ring" set ref 1723 1723 1726* 1726 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 2015 in procedure "move_forward_word" set ref 2019 2024 2030 2032* 2034* 2034 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1970 in procedure "get_current_word_info" set ref 1972 1974 1978 1979 1981 1982* 1986 1988 1989* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 2082 in procedure "insert_in_buffer" set ref 2094 2096 2096 2098 2100* 2100 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 131 in procedure "window_io_iox_" set ref 400* 417* 2198 2201* 2268 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1843 in procedure "initial_capital" ref 1875 cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1678 in procedure "forward_delete_word" set ref 1684 1686 1687* cursor_index 10 based fixed bin(21,0) level 2 in structure "LEI" dcl 1235 in procedure "kill_to_end_of_line" ref 1238 cursor_index 10 based fixed bin(21,0) level 2 in structure "line_editor_info" dcl 5-8 in procedure "window_io_iox_" set ref 1032 1034* 1034 1044 1046* 1046 cursor_line 000104 automatic fixed bin(17,0) dcl 2184 set ref 2269* 2279* 2282 2282* 2282 2294* cursor_position 71 based structure level 2 dcl 1-29 cursor_valid 66(11) based bit(1) level 3 packed packed unaligned dcl 1-29 set ref 3040* cv_trans based structure level 1 dcl 10-62 debug 66(01) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 2958 decomp 000101 automatic structure level 1 packed packed unaligned dcl 2464 set ref 2473* defined_text defined char packed unaligned dcl 2420 set ref 2422* delay based structure level 1 dcl 10-66 delete_count parameter fixed bin(21,0) dcl 2110 set ref 2106 2122 2132 2135* 2138 2139 2141 description 32 based varying char(256) array level 3 dcl 1-155 set ref 243* 295* digit_1 000101 automatic fixed bin(3,0) level 2 packed packed unsigned unaligned dcl 2464 set ref 2477 digit_2 0(03) 000101 automatic fixed bin(3,0) level 2 packed packed unsigned unaligned dcl 2464 set ref 2478 digit_3 0(06) 000101 automatic fixed bin(3,0) level 2 packed packed unsigned unaligned dcl 2464 set ref 2479 digit_table 000052 constant char(1) initial array packed unaligned dcl 2469 ref 2477 2478 2479 discard_output 66 based bit(1) level 3 packed packed unaligned dcl 1-29 set ref 361* 3304* 3316* 3330 3376* dispatch_table based structure level 1 dcl 1-155 set ref 201 249 321 dispatch_table_ptr 000434 automatic pointer dcl 1-153 in procedure "window_io_iox_" set ref 201* 204 205 209 212 214 215 217 218 219 221 222 224 226 227 229 230 231 232 234 236 239 240 241 243 243 243 243 246 254 255 257* 261 262 263 264 265 266 267 268 269 270 271 273 274 275 276 277 278 279 280 282 283 284 285 286 287 288 289 291 292 293 295 295 295 295 723* 732 732* 732 745 746* 746 753 753 756 757 786 dispatch_table_ptr 176 based pointer level 2 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" set ref 246* 306* 723 divide builtin function dcl 181 ref 2274 echoed_chars defined char packed unaligned dcl 670 set ref 671* 676* edited 66(14) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 2471 2501 edited_escapes based structure array level 2 dcl 10-26 set ref 2507* editing_chars 144 based structure level 2 dcl 1-29 editor_routine 000110 automatic entry variable dcl 717 set ref 756* 782 808* 813* 818* 823* 828* 833* 838* 843* 848* 853* 858* 863* 868* 873* 878* 883* 888* 893* 898* 903* 908* 913* 918* 923* 928* 933* 938* 943* 948* 953* 958* 963* 968* 973* 978* 983* 988* 993* end 000101 automatic fixed bin(17,0) dcl 1898 in procedure "twiddle_words" set ref 1904* 1910* 1914 1915 1917 end parameter fixed bin(17,0) dcl 1967 in procedure "get_current_word_info" set ref 1959 1974* 1981* 1988* end 000101 automatic fixed bin(17,0) dcl 1840 in procedure "initial_capital" set ref 1865* 1875 end 000101 automatic fixed bin(17,0) dcl 1772 in procedure "lowercase_word" set ref 1801* 1804 1815 end2 000103 automatic fixed bin(17,0) dcl 1899 set ref 1931* 1934 1935 1944 erase_char 144 based char(1) level 3 dcl 1-29 ref 240 293 1411 error_table_$action_not_performed 000012 external static fixed bin(35,0) dcl 168 ref 764 772 799 1032 1044 1142 1258 1736 2091 2132 error_table_$bad_subr_arg 000016 external static fixed bin(35,0) dcl 168 ref 342 error_table_$long_record 000010 external static fixed bin(35,0) dcl 168 ref 381 502 error_table_$null_info_ptr 000100 external static fixed bin(35,0) dcl 1090 ref 1096 error_table_$unimplemented_version 000102 external static fixed bin(35,0) dcl 1092 in procedure "setup_util_call" ref 1101 error_table_$unimplemented_version 000014 external static fixed bin(35,0) dcl 168 in procedure "window_io_iox_" ref 337 escape_index 000105 automatic fixed bin(21,0) dcl 1344 set ref 1351* 1388 1389 1406 1414 1427 escape_length 54 based fixed bin(17,0) level 2 dcl 10-26 ref 1424 1424 1425 1425 1425 1425 1431 1431 1431 1431 1431 1431 1431 1431 1431 1431 1431 1431 2507 extent 3 000100 automatic structure level 2 dcl 2977 find_char_$translate_first_in_table 000110 constant entry external dcl 2417 ref 2422 first_letter defined char(1) packed unaligned dcl 1868 set ref 1869* 1869 fixed builtin function dcl 181 ref 1365 1377 1634 1637 1640 flags 5 based structure level 2 in structure "LEI" packed packed unaligned dcl 2761 in procedure "add_to_kill_ring" flags 5 based structure level 2 in structure "LEI" dcl 1268 in procedure "terminate_input_line" flags 5 based structure level 2 in structure "LEI" dcl 1578 in procedure "multiplier" flags 5 based structure level 2 in structure "LEI" dcl 1300 in procedure "quote_character" flags 5 based structure level 2 in structure "LEI" dcl 719 in procedure "process_break" flags 5 based structure level 2 in structure "LEI" dcl 131 in procedure "window_io_iox_" flags 66 based structure level 2 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" flags 5 based structure level 2 in structure "LEI" packed packed unaligned dcl 1843 in procedure "initial_capital" flags 5 based structure level 2 in structure "LEI" dcl 612 in procedure "read_input_line" flags 5 based structure level 2 in structure "LEI" dcl 1616 in procedure "read_numbers_then_dispatch" flags 5 based structure level 2 in structure "LEI" packed packed unaligned dcl 1776 in procedure "lowercase_word" freen_ 000076 constant entry external dcl 561 ref 566 get_line_entry_column 000104 automatic fixed bin(17,0) dcl 114 set ref 426* 550* 1290* 1760* 2208 2221 2222 2225 2274 2286 2315* get_line_entry_line 000103 automatic fixed bin(17,0) dcl 113 set ref 425* 549* 1289* 1759* 2208 2209 2211 2211 2220 2279 2313 2313* 2313 get_system_free_area_ 000034 constant entry external dcl 1-115 ref 2858 2886 2903 got_response 000155 automatic bit(1) dcl 3092 set ref 3192* 3207* 3213 height 4 000100 automatic fixed bin(17,0) level 3 dcl 2977 set ref 2992* 3010* i 000105 automatic fixed bin(17,0) dcl 715 in procedure "process_break" set ref 777* i 000154 automatic fixed bin(17,0) dcl 3091 in procedure "perform_more_break" set ref 3144* 3145 3145* 3150* 3151 3151* i 000102 automatic fixed bin(17,0) dcl 1773 in procedure "lowercase_word" set ref 1799* 1817* i 000102 automatic fixed bin(17,0) dcl 1841 in procedure "initial_capital" set ref 1859* 1877* index builtin function dcl 181 ref 1425 3200 3203 info_dir 133 based char(168) array level 4 dcl 1-155 set ref 243* 295* info_entry 205 based char(32) array level 4 dcl 1-155 set ref 243* 295* info_path 133 based structure array level 3 dcl 1-155 initial_text based char packed unaligned dcl 413 set ref 414* input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 1776 in procedure "lowercase_word" set ref 1806* 1806 1806 1806 1808* 1808 1808 1808 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 1901 in procedure "twiddle_words" ref 1915 1935 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 2015 in procedure "move_forward_word" ref 2024 2024 2030 2030 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 1718 in procedure "yank_previous_from_kill_ring" ref 1723 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 719 in procedure "process_break" ref 790 790 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 2761 in procedure "add_to_kill_ring" ref 2768 2768 2795 2795 2799 2799 2801 2801 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 401* 479 492 501 2197 2197 2201 2201 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 1248 in procedure "twiddle_characters" set ref 1254 1255* 1255 1256* input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 1843 in procedure "initial_capital" set ref 1869* 1869 1869 1869 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 2049 in procedure "move_backward_word" ref 2057 2057 2063 2063 input_buffer defined char packed unaligned dcl 2191 in procedure "redisplay_input_line" set ref 2197 2201* input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 2114 in procedure "delete_from_buffer" set ref 2139* 2139 input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 2082 in procedure "insert_in_buffer" set ref 2091 2096* 2096 2098* input_buffer 12 based char(512) level 2 in structure "LEI" packed packed unaligned dcl 612 in procedure "read_input_line" ref 633 639 input_char 000100 automatic varying char(1) dcl 1341 set ref 1360* 1364 1364 1365 1366 1373* 1375 1375 1377 1378 1384 1403 1411 1411 1411 1418 1425 1438 input_escape_char 146 based char(1) level 3 dcl 1-29 ref 241 1354 1411 2475 input_escapes based structure level 2 dcl 10-26 input_results based structure level 2 dcl 10-26 input_string parameter char packed unaligned dcl 2333 ref 2329 2352 2357 2359 2359 2364 2374 2374 2375 2375 2376 2380 2380 2388 2388 2388 2388 interesting_char 001131 automatic char(1) packed unaligned dcl 2586 set ref 2629* 2630* 2644 interesting_char_index 001127 automatic fixed bin(21,0) dcl 2584 set ref 2601* 2603 2606 2607* 2607 2625 2629 interesting_char_type 001130 automatic fixed bin(17,0) dcl 2585 set ref 2601* 2613 2630* 2634 2640 2648 2648 2664 2664 ioa_ 000104 constant entry external dcl 1747 ref 1751 ioa_$rsnnl 000114 constant entry external dcl 3100 ref 3155 iocb based structure level 1 dcl 12-6 iocb_ptr 000106 automatic pointer dcl 115 in procedure "window_io_iox_" set ref 196* 197 303* 304 353* 355 394 454* 462* 508* 531* 1105* 1107 2265* 2294* 2308* 2538* 2548* 2553* 2557* 2562* 2656* 2658* 2669* 2726* 2928* 2964* 3015* 3034* 3050* 3061* 3109 3173* 3222* 3227* 3233* 3236* 3244* 3251* 3257* 3260* 3266* 3269* 3313* 3314 3323* 3324 3346* 3353* 3373* 3374 3384* 3401* iocb_ptr 2 based pointer level 2 in structure "LEI" dcl 719 in procedure "process_break" set ref 735* 747* iocb_ptr 2 based pointer level 2 in structure "line_editor_info" dcl 5-8 in procedure "window_io_iox_" ref 1105 iocb_ptr 2 based pointer level 2 in structure "LEI" dcl 131 in procedure "window_io_iox_" set ref 394* iocb_ptr 2 based pointer level 2 in structure "LEI" dcl 1616 in procedure "read_numbers_then_dispatch" set ref 1620* iocb_ptr 2 based pointer level 2 in structure "LEI" dcl 1339 in procedure "process_input_escape" set ref 1360* 1373* 1404* iocb_ptr 2 based pointer level 2 in structure "LEI" dcl 612 in procedure "read_input_line" set ref 634* 645* 651* iocb_ptr 2 based pointer level 2 in structure "LEI" dcl 1300 in procedure "quote_character" set ref 1307* iox_$control 000072 constant entry external dcl 11-8 ref 531 580 2986 3015 iox_$put_chars 000074 constant entry external dcl 11-8 ref 3401 k 000114 automatic pointer dcl 2820 in procedure "insert_new_kill_ring_element" set ref 2822* 2828 2829 2830 k 000152 automatic pointer dcl 2883 in procedure "expand_kill_ring_element" set ref 2886* 2887 2889 2889 2892 2893 2896 2896 2899 2900 2904 key based structure array level 2 dcl 1-155 key_idx 000102 automatic fixed bin(17,0) dcl 112 set ref 208* 209* 316* 317 317* key_sequence 212 based char(128) level 2 in structure "LEI" dcl 719 in procedure "process_break" set ref 725* 750* 750 key_sequence 212 based char(128) level 2 in structure "LEI" dcl 1119 in procedure "self_insert" ref 1123 1125 1125 kill_char 145 based char(1) level 3 dcl 1-29 set ref 239 1411 1751* kill_direction parameter bit(1) dcl 2111 in procedure "delete_from_buffer" set ref 2122 2135* kill_direction parameter bit(1) dcl 2752 in procedure "add_to_kill_ring" ref 2746 2793 2799 kill_ring_info 164 based structure level 2 dcl 1-29 killer based structure level 1 unaligned dcl 1-118 set ref 2858 2886 2889 2896 2903 killer_alloc_size 000432 automatic fixed bin(17,0) dcl 1-124 set ref 2857* 2858 2858 2885* 2886 2886 killer_count 000100 automatic fixed bin(17,0) dcl 2754 set ref 2776* 2780 killer_initial_alloc_size constant fixed bin(17,0) initial dcl 1-125 ref 2857 killer_ptr parameter pointer dcl 2867 ref 2864 2871 2871 2872 2872 2874 2875 last_character_column 000103 automatic fixed bin(17,0) dcl 2183 set ref 2225* 2244* 2262* 2270 last_character_line 000102 automatic fixed bin(17,0) dcl 2182 set ref 2224* 2243* 2261* 2269 last_kill_direction 5(03) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 2761 in procedure "add_to_kill_ring" set ref 2793* last_kill_direction 5(03) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 404* lei_ptr parameter pointer dcl 2749 in procedure "add_to_kill_ring" ref 2746 2768 2768 2789 2792 2793 2795 2799 2801 lei_ptr parameter pointer dcl 1132 in procedure "backward_delete_character" set ref 1129 1138 1139 1139 1140* lei_ptr parameter pointer dcl 1594 in procedure "negative_number_reader" set ref 1591 1600 1601* lei_ptr parameter pointer dcl 1322 in procedure "yank_from_kill_ring" set ref 1319 1328* 1329 lei_ptr parameter pointer dcl 1557 in procedure "number_reader_common" set ref 1554 1566* lei_ptr parameter pointer dcl 1232 in procedure "kill_to_end_of_line" set ref 1229 1238* 1238 1238 lei_ptr parameter pointer dcl 1297 in procedure "quote_character" set ref 1294 1307 1309 1309 1314* lei_ptr parameter pointer dcl 1167 in procedure "backward_character" ref 1164 1173 1173 1173 lei_ptr parameter pointer dcl 1969 in procedure "get_current_word_info" set ref 1959 1972 1973* 1974 1976* 1978 1979 1980* 1981 1982 1985* 1986 1987* 1988 1989 lei_ptr parameter pointer dcl 1118 in procedure "self_insert" set ref 1115 1123 1123* 1125* 1125 1125 lei_ptr parameter pointer dcl 2044 in procedure "move_backward_word" ref 2041 2053 2057 2063 2065 2067 2067 lei_ptr parameter pointer dcl 1181 in procedure "forward_character" ref 1178 1187 1187 1187 1187 lei_ptr parameter pointer dcl 1744 in procedure "display_editor_documentation" ref 1741 lei_ptr parameter pointer dcl 1284 in procedure "clear_window" ref 1281 lei_ptr parameter pointer dcl 1546 in procedure "number_reader_9" set ref 1543 1549* lei_ptr parameter pointer dcl 2178 in procedure "redisplay_input_line" ref 2175 lei_ptr parameter pointer dcl 1696 in procedure "backward_delete_word" set ref 1693 1705 1706* 1707 1708* lei_ptr parameter pointer dcl 1675 in procedure "forward_delete_word" set ref 1672 1684 1685* 1686 1687 1688* lei_ptr parameter pointer dcl 1715 in procedure "yank_previous_from_kill_ring" set ref 1712 1723 1723 1723 1726 1726 1727* 1732* lei_ptr parameter pointer dcl 1524 in procedure "number_reader_7" set ref 1521 1527* lei_ptr parameter pointer dcl 1149 in procedure "kill_to_beginning_of_line" set ref 1146 1157 1158 1159* lei_ptr parameter pointer dcl 1837 in procedure "initial_capital" set ref 1834 1848 1848 1854 1854 1857 1861* 1865* 1869 1869 1872* 1873* 1875 1884* 1885* 1886* lei_ptr parameter pointer dcl 1609 in procedure "read_numbers_then_dispatch" set ref 1606 1618 1620 1626 1634 1634 1637 1637 1640 1640 1640 1644* lei_ptr parameter pointer dcl 708 in procedure "process_break" set ref 705 725 735 747 750 750 763 763 768 768 771 779 779 780 782* 788 788 790 790 790 790 792 792 794 794 794 794 lei_ptr parameter pointer dcl 2078 in procedure "insert_in_buffer" ref 2075 2091 2091 2094 2094 2096 2096 2096 2096 2098 2098 2099 2099 2100 2100 lei_ptr parameter pointer dcl 2109 in procedure "delete_from_buffer" set ref 2106 2122 2132 2132 2135* 2135 2138 2138 2139 2139 2139 2139 2141 2141 lei_ptr parameter pointer dcl 1221 in procedure "forward_delete_character" set ref 1218 1225* lei_ptr parameter pointer dcl 1895 in procedure "twiddle_words" set ref 1892 1904* 1908* 1909* 1910* 1915 1915 1917* 1921* 1925 1927* 1931 1935 1937 1938* 1943 1944* 1947* 1951* lei_ptr 000124 automatic pointer dcl 129 in procedure "window_io_iox_" set ref 391* 393 394 395 396 397 398 399 400 401 402 403 404 405 414* 417 473* 478 479 479 483 484* 490 492 493 493 495 498 501 501 535 535 1562 1562 1562 1564 2191 2197 2198 2201 2201 2268 2268 lei_ptr parameter pointer dcl 1664 in procedure "forward_word" set ref 1661 1668* lei_ptr parameter pointer dcl 1265 in procedure "terminate_input_line" set ref 1262 1271 1272 1273 1274 1274 1275* 1276* lei_ptr parameter pointer dcl 1491 in procedure "number_reader_4" set ref 1488 1494* lei_ptr parameter pointer dcl 1336 in procedure "process_input_escape" set ref 1333 1351 1354* 1358* 1360 1366* 1369* 1373 1378* 1382* 1388 1389 1390* 1393* 1398* 1404 1406 1407* 1414 1415* 1418* 1427 1428* 1431* 1438* lei_ptr parameter pointer dcl 1513 in procedure "number_reader_6" set ref 1510 1516* lei_ptr parameter pointer dcl 1195 in procedure "move_to_beginning_of_line" ref 1192 1201 lei_ptr parameter pointer dcl 1535 in procedure "number_reader_8" set ref 1532 1538* lei_ptr parameter pointer dcl 600 in procedure "read_input_line" set ref 597 618 618* 633 633 634 639 639 645 645 645 651 665 671* 684 685 686* 687 688 689* 696* lei_ptr parameter pointer dcl 1469 in procedure "number_reader_2" set ref 1466 1472* lei_ptr parameter pointer dcl 1458 in procedure "number_reader_1" set ref 1455 1461* lei_ptr parameter pointer dcl 1447 in procedure "number_reader_0" set ref 1444 1450* lei_ptr parameter pointer dcl 1480 in procedure "number_reader_3" set ref 1477 1483* lei_ptr parameter pointer dcl 1245 in procedure "twiddle_characters" ref 1242 1253 1254 1254 1255 1255 1255 1255 1256 1256 lei_ptr parameter pointer dcl 1502 in procedure "number_reader_5" set ref 1499 1505* lei_ptr parameter pointer dcl 1208 in procedure "move_to_end_of_line" ref 1205 1214 1214 lei_ptr parameter pointer dcl 1575 in procedure "multiplier" set ref 1572 1581 1581 1581 1583 1586* lei_ptr parameter pointer dcl 2010 in procedure "move_forward_word" ref 2007 2019 2019 2024 2024 2030 2030 2032 2032 2034 2034 lei_ptr parameter pointer dcl 1769 in procedure "lowercase_word" set ref 1766 1781 1790 1790 1796 1796 1801* 1806 1806 1808 1808 1812* 1813* 1815 1817 1824* 1825* 1826* lei_ptr parameter pointer dcl 1653 in procedure "backward_word" set ref 1650 1657* len based fixed bin(8,0) level 3 packed packed unaligned dcl 10-26 ref 1424 1425 1431 1431 1431 1431 length builtin function dcl 181 ref 375 379 633 639 683 790 790 1372 1398 1723 1723 1723 1726 1727 1727 2091 2091 2096 2098 2099 2100 2165 2197 2229 2262 2274 2286 2352 2357 2364 2375 2376 2420 2523 2598 2603 2614 2678 2678 2703 2703 2706 2795 2795 3170 3188 3360 3362 3389 leud_ptr parameter pointer dcl 558 set ref 555 564 565 566* 567* line 000106 automatic fixed bin(17,0) dcl 2186 in procedure "redisplay_input_line" set ref 2211* 2212 2213 2214* 2220* 2222 2223 2224 2232* 2232 2233 2236* 2238* 2240 2241 2243 2250* 2250 2251 2254* 2256* 2258 2260 2261 line parameter fixed bin(17,0) dcl 2161 in procedure "add_to_window_image" ref 2157 2165 2166 line 71 based fixed bin(17,0) level 3 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" set ref 425 549 628 1759 2537 2538 2553* 2666 3079 3227* 3251* 3257* 3266* 3344 line 000126 automatic fixed bin(17,0) dcl 2301 in procedure "scroll_window_image" set ref 2303* 2304 2304 2305 2305* line 2 000100 automatic fixed bin(17,0) level 3 in structure "auto_window_position_info" dcl 2977 in procedure "resize_window" set ref 2993* 3005* line_editor_breaks 152(20) based bit(128) level 2 packed packed unaligned dcl 1-29 ref 650 line_editor_info based structure level 1 dcl 5-8 line_editor_info_version_2 000056 constant char(8) initial packed unaligned dcl 5-31 ref 393 1100 line_editor_user_data_header based structure level 1 dcl 5-40 line_idx 000100 automatic fixed bin(17,0) dcl 577 set ref 583* 584 584* line_left 001124 automatic fixed bin(17,0) dcl 2581 in procedure "put_out_chars" set ref 2596* 2616* 2619* 2630 2636* 2678* line_left parameter fixed bin(17,0) dcl 2690 in procedure "write_with_continuation" set ref 2685 2700 2701* 2704 2705 2706* 2712* 2712 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 1235 in procedure "kill_to_end_of_line" ref 1238 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 1184 in procedure "forward_character" ref 1187 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 2015 in procedure "move_forward_word" ref 2019 2032 line_length 11 based fixed bin(21,0) level 2 in structure "line_editor_info" dcl 5-8 in procedure "window_io_iox_" ref 1032 line_length 4 based fixed bin(21,0) level 2 in structure "window_edit_line_info" dcl 7-177 in procedure "window_io_iox_" ref 341 411 414 414 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 2082 in procedure "insert_in_buffer" set ref 2091 2094 2099* 2099 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 1211 in procedure "move_to_end_of_line" ref 1214 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 612 in procedure "read_input_line" ref 618 633 639 645 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 131 in procedure "window_io_iox_" set ref 399* 478 479 490 493* 493 495 498 501 2191 2268 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 719 in procedure "process_break" set ref 788 788* 790 790* 794 794 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 2114 in procedure "delete_from_buffer" set ref 2132 2138 2141* 2141 line_length 11 based fixed bin(21,0) level 2 in structure "LEI" dcl 1268 in procedure "terminate_input_line" ref 1274 line_offset 000111 automatic fixed bin(17,0) dcl 2189 set ref 2274* 2277* 2277 2279 2286 line_origin 161 based fixed bin(17,0) level 3 dcl 1-29 ref 584 2993 3005 3010 3010 line_ptr 2 based pointer level 2 dcl 7-177 ref 414 lines 3 based char array level 2 packed packed unaligned dcl 9-4 ref 584 lines_written_since_read 70 based fixed bin(17,0) level 2 dcl 1-29 set ref 365* 506* 2535* 2535 2653* 3074 3120* 3162* 3242* 3276* 3377* lowercase 000060 constant char(26) initial packed unaligned dcl 164 ref 1806 1808 1869 max builtin function dcl 181 ref 2277 max_size 4 based fixed bin(21,0) level 2 dcl 1-118 set ref 2795 2799 2801 2833 2858* 2860 2885 2886* 2887 2903 maxlength builtin function dcl 181 ref 2795 merge_next_kill 5(01) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 612 in procedure "read_input_line" set ref 665* merge_next_kill 5(01) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 719 in procedure "process_break" set ref 779 780* merge_next_kill 5(01) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1268 in procedure "terminate_input_line" set ref 1273* merge_next_kill 5(01) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 2761 in procedure "add_to_kill_ring" set ref 2792* merge_next_kill 5(01) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 402* min builtin function dcl 181 ref 375 490 639 2221 mod builtin function dcl 181 ref 2286 2450 more_data 000162 automatic structure level 1 unaligned dcl 3096 set ref 3125 3125 more_handler 202 based entry variable level 2 dcl 1-29 ref 3125 more_handler_in_use 200 based bit(1) level 2 dcl 1-29 ref 3105 more_info based structure level 1 dcl 8-5 more_info_version constant fixed bin(17,0) initial dcl 8-16 ref 3108 more_mode 1 000162 automatic fixed bin(17,0) level 2 in structure "more_data" dcl 3096 in procedure "perform_more_break" set ref 3110* more_mode 75 based fixed bin(17,0) level 2 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" ref 2233 2251 2546 2651 2651 3074 3074 3110 3220 3226 3232 3249 3256 3265 more_noes 42 000162 automatic char(32) level 3 in structure "more_data" packed packed unaligned dcl 3096 in procedure "perform_more_break" set ref 3115* more_noes 134 based char(32) level 3 in structure "attach_data" packed packed unaligned dcl 1-29 in procedure "window_io_iox_" ref 3115 3151 3151 3203 3203 more_processing 66(02) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 3070 more_prompt 4 000162 automatic char(80) level 2 in structure "more_data" packed packed unaligned dcl 3096 in procedure "perform_more_break" set ref 3111* more_prompt 76 based char(80) level 2 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" set ref 3111 3155* more_responses 122 based structure level 2 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" more_responses 30 000162 automatic structure level 2 in structure "more_data" unaligned dcl 3096 in procedure "perform_more_break" more_yeses 32 000162 automatic char(32) level 3 in structure "more_data" packed packed unaligned dcl 3096 in procedure "perform_more_break" set ref 3114* more_yeses 124 based char(32) level 3 in structure "attach_data" packed packed unaligned dcl 1-29 in procedure "window_io_iox_" ref 3114 3145 3145 3200 3200 move_count 000101 automatic fixed bin(17,0) dcl 2117 set ref 2138* 2139 2139 multiplier_flag parameter bit(1) packed unaligned dcl 1611 set ref 1606 1624 1628* n_columns 1 based fixed bin(17,0) level 2 dcl 9-4 ref 584 584 584 n_noes 123 based fixed bin(17,0) level 3 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" ref 3113 3150 3198 n_noes 31 000162 automatic fixed bin(17,0) level 3 in structure "more_data" dcl 3096 in procedure "perform_more_break" set ref 3113* n_yeses 30 000162 automatic fixed bin(17,0) level 3 in structure "more_data" dcl 3096 in procedure "perform_more_break" set ref 3112* n_yeses 122 based fixed bin(17,0) level 3 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" ref 3112 3144 3197 name 11 based varying char(64) array level 3 dcl 1-155 set ref 243* 295* new 000134 automatic pointer dcl 2855 set ref 2858* 2859 2859 2860 2861 new_input defined char packed unaligned dcl 2357 set ref 2359* 2374 2375 2380 2388 2388 next based pointer level 2 dcl 1-118 set ref 2774 2777 2810 2828* 2831* 2846 2859* 2871* 2871 2872 2874* 2889 2889* 2892* 2892 2893 2900* next_char 000100 automatic varying char(1) dcl 1614 set ref 1620* 1624 1632 1632 1634 1637 1640 1644 next_table 2 based pointer array level 3 dcl 1-155 set ref 254* 317* 732 746 next_user_data_ptr 2 based pointer level 2 dcl 562 ref 565 noes_string 000141 automatic varying char(40) dcl 3089 set ref 3149* 3151* 3151 3152* 3152 3155* not_edited_escapes 55 based structure array level 2 dcl 10-26 set ref 2501* null builtin function dcl 181 ref 199 308 351 367 374 385 405 410 418 433 434 519 522 535 564 1095 2825 2846 2859 2965 2965 3379 numarg_action 000107 automatic fixed bin(17,0) dcl 716 in procedure "process_break" set ref 757* 763 768 771 810* 815* 820* 825* 830* 835* 840* 845* 850* 855* 860* 865* 870* 875* 880* 885* 890* 895* 900* 905* 910* 915* 920* 925* 930* 935* 940* 945* 950* 955* 960* 965* 970* 975* 980* 985* 990* 995* numarg_action 10 based fixed bin(17,0) array level 3 in structure "dispatch_table" dcl 1-155 in procedure "window_io_iox_" ref 757 numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 612 in procedure "read_input_line" set ref 685* numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 396* 1562 numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1578 in procedure "multiplier" ref 1581 numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1776 in procedure "lowercase_word" ref 1790 1796 1817 numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 719 in procedure "process_break" ref 763 768 771 numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1300 in procedure "quote_character" ref 1309 numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1616 in procedure "read_numbers_then_dispatch" set ref 1618* numarg_given 5(04) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1843 in procedure "initial_capital" set ref 1848 1854 1857* number parameter fixed bin(17,0) dcl 1559 ref 1554 1562 1564 number_returned 000470 automatic fixed bin(21,0) dcl 603 set ref 625* 651* 663 670 number_to_read 000471 automatic fixed bin(21,0) dcl 604 set ref 624* 639* 639 645 651* number_to_save 000110 automatic fixed bin(21,0) dcl 116 set ref 478* 479* 479 482 484* octal_rep 000100 automatic char(4) packed unaligned dcl 2462 set ref 2475* 2477* 2478* 2479* 2482 old_cursor 000101 automatic fixed bin(21,0) dcl 1681 in procedure "forward_delete_word" set ref 1684* 1686 1687 old_cursor 000101 automatic fixed bin(21,0) dcl 1702 in procedure "backward_delete_word" set ref 1705* 1707 old_cursor 000100 automatic fixed bin(21,0) dcl 1154 in procedure "kill_to_beginning_of_line" set ref 1157* 1159 old_merge_next_kill 5(02) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 2761 in procedure "add_to_kill_ring" ref 2768 2789 old_merge_next_kill 5(02) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 719 in procedure "process_break" set ref 779* old_merge_next_kill 5(02) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 403* 483* ordinary_count 001125 automatic fixed bin(21,0) dcl 2582 set ref 2603* 2606* 2614 2619* 2621 2622 origin 1 000100 automatic structure level 2 dcl 2977 output_string parameter char packed unaligned dcl 2335 set ref 2329 2347* 2374* 2380* 2388* prev 2 based pointer level 2 dcl 1-118 set ref 2781 2829* 2829 2830* 2831 2859* 2871 2872* 2872 2893* 2896 2896* 2899* 2899 2900 processed 000110 automatic fixed bin(21,0) dcl 2188 set ref 2205* 2221* 2222 2225 2231 2240 2242* 2242 2249 2258 2258 2262 prompt 000101 automatic varying char(80) dcl 3088 set ref 3155* 3170 3170* 3170 3173 3173 3178* quit 000234 stack reference condition dcl 3098 ref 3118 3127 3160 3175 r 000157 automatic char(1) packed unaligned dcl 3094 set ref 3188* 3190* 3200 3203 rank builtin function dcl 181 ref 239 240 241 261 262 263 264 265 266 267 268 269 270 271 273 274 275 276 277 278 279 280 282 283 284 285 286 287 288 289 291 292 293 741 745 746 753 753 756 757 786 2424 2433 2434 3287 3287 rawo 66(07) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 3333 read_buffer 000475 automatic char(1024) packed unaligned dcl 610 set ref 651* 671 671 676 676 read_start_column 000473 automatic fixed bin(17,0) dcl 605 set ref 629* 676* read_start_line 000472 automatic fixed bin(17,0) dcl 605 set ref 628* 676* reconnection 67(03) based bit(1) level 3 packed packed unaligned dcl 1-29 set ref 456 2924 red 66(08) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 2664 red_ribbon_shift 40 based structure level 2 dcl 10-26 set ref 2491* redisplay_buffer based char(2048) packed unaligned dcl 124 set ref 440 519 2196* 2201* 2222 2240 2258 redisplay_buffer_ptr 000120 automatic pointer dcl 122 set ref 433* 440* 519 519 2196 2201 2222 2240 2258 repeat_count 000103 automatic fixed bin(17,0) dcl 1304 in procedure "quote_character" set ref 1309* 1311* 1313 repeat_count 000103 automatic fixed bin(17,0) dcl 1841 in procedure "initial_capital" set ref 1846* 1854* 1859 1877 1877 repeat_count 000106 automatic fixed bin(17,0) dcl 715 in procedure "process_break" set ref 760* 768* 777 repeat_count 000103 automatic fixed bin(17,0) dcl 1773 in procedure "lowercase_word" set ref 1788* 1796* 1799 1817 repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 1776 in procedure "lowercase_word" ref 1790 1796 repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 1616 in procedure "read_numbers_then_dispatch" set ref 1626* 1634* 1634 1637 1637* 1640* 1640 1640 repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 1300 in procedure "quote_character" ref 1309 repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 1843 in procedure "initial_capital" ref 1848 1854 repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 719 in procedure "process_break" ref 763 768 repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 1597 in procedure "negative_number_reader" set ref 1600* repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 1578 in procedure "multiplier" set ref 1581* 1581 1583* repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 131 in procedure "window_io_iox_" set ref 395* 1562* 1562 1564* repetition_count 4 based fixed bin(17,0) level 2 in structure "LEI" dcl 612 in procedure "read_input_line" set ref 684* replace_count_flag parameter bit(1) packed unaligned dcl 1612 set ref 1606 1627* 1633 1635* reput_str defined char packed unaligned dcl 3360 set ref 3362 3362* response 000156 automatic char(1) packed unaligned dcl 3093 set ref 3173* 3190 result 000107 automatic fixed bin(17,0) dcl 1346 set ref 1365* 1376* 1376 1377* 1377 1393 1393 return_from_editor 5 based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1268 in procedure "terminate_input_line" set ref 1271* return_from_editor 5 based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 612 in procedure "read_input_line" ref 687 return_from_editor 5 based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 397* reverse builtin function dcl 181 ref 2057 2063 routine 4 based entry variable array level 3 dcl 1-155 ref 756 row_at_rawo 73 based fixed bin(17,0) level 3 dcl 1-29 set ref 462* rows 157 based fixed bin(17,0) level 3 in structure "attach_data" dcl 1-29 in procedure "window_io_iox_" set ref 439 522 583 589 1998 1999 2211 2233 2236 2251 2254 2265 2282 2282 2303 2308* 2537 2548* 2653 2658* 2992 3010 3074 3079 3222* 3233* 3344 3346* rows 2 000105 automatic fixed bin(17,0) level 3 in structure "auto_capabilities_info" dcl 2979 in procedure "resize_window" set ref 3005 3010 3010 rtrim builtin function dcl 181 ref 750 1125 1125 1938 1938 1947 1947 2614 3170 3173 3173 save_on_kill_ring 000100 automatic bit(1) packed unaligned dcl 2116 set ref 2119* 2125* 2135 saved_buffer based structure level 1 dcl 138 set ref 308 384 499 saved_buffer_length 000400 automatic fixed bin(17,0) dcl 136 set ref 498* 499 499 saved_buffer_ptr 174 based pointer level 2 dcl 1-29 set ref 199* 308 308 374 375 376 379 380 380 384 385* 499* 501 saved_column 001155 automatic fixed bin(17,0) dcl 2590 set ref 2667* 2669* saved_length based fixed bin(17,0) level 2 dcl 138 set ref 308 380 384 499* 501 saved_line 001154 automatic fixed bin(17,0) dcl 2590 set ref 2666* 2669* screen based structure level 1 dcl 9-4 screen_invalid 67 based bit(1) level 3 packed packed unaligned dcl 1-29 set ref 2928 3039* screen_ptr 000442 automatic pointer dcl 9-12 set ref 580* 584 screensize 1 000105 automatic structure level 2 dcl 2979 search builtin function dcl 181 ref 2024 2057 sign builtin function dcl 181 ref 1634 1640 special_chars based structure level 1 dcl 10-26 special_length parameter fixed bin(17,0) dcl 2519 set ref 2515 2523* special_ptr 172 based pointer level 2 dcl 1-29 ref 1424 1425 1431 1431 2491 2496 2501 2507 special_string defined char packed unaligned dcl 2521 ref 2523 2524 start 000140 automatic fixed bin(21,0) dcl 2342 in procedure "perform_output_conversions" set ref 2350* 2352 2357 2359 2366 2369 2369 2374 2375 2376* 2380 2388 2388 2392* 2392 start 000100 automatic fixed bin(17,0) dcl 1840 in procedure "initial_capital" set ref 1865* 1869 1869 start 000100 automatic fixed bin(17,0) dcl 1772 in procedure "lowercase_word" set ref 1801* 1804 1806 1806 1808 1808 start parameter fixed bin(17,0) dcl 1967 in procedure "get_current_word_info" set ref 1959 1972* 1978 1979* 1982 1986* 1989 start 000100 automatic fixed bin(17,0) dcl 1898 in procedure "twiddle_words" set ref 1904* 1906 1910* 1914 1915 1917 1937 start2 000102 automatic fixed bin(17,0) dcl 1899 set ref 1925* 1934 1935 1935 1943 1944 start_idx parameter fixed bin(21,0) dcl 2750 in procedure "add_to_kill_ring" ref 2746 2768 2795 2799 2801 start_idx 001165 automatic fixed bin(21,0) dcl 2693 in procedure "write_with_continuation" set ref 2696* 2700 2704* 2704 2710 start_index parameter fixed bin(21,0) dcl 2334 in procedure "perform_output_conversions" ref 2329 2350 start_index parameter fixed bin(21,0) dcl 2411 in procedure "scan_for_interesting_char" ref 2407 2420 2422 start_ptr 001166 automatic pointer dcl 2694 set ref 2697* 2701* 2705* 2705 2711* status 67 based structure level 2 dcl 1-29 set ref 458* 2931* 3131* 3183* status_pending 66(10) based bit(1) level 3 packed packed unaligned dcl 1-29 set ref 457* 2927* 3038* 3130* 3182* str based char level 3 in structure "special_chars" packed packed unaligned dcl 10-26 in procedure "window_io_iox_" ref 1431 1431 str based char level 3 in structure "special_chars" packed packed unaligned dcl 10-26 in procedure "window_io_iox_" ref 1425 string builtin function dcl 181 set ref 458* 530* 2931* 3131* 3183* sub_err_ 000112 constant entry external dcl 2953 ref 2965 sub_err_action 000100 automatic bit(36) dcl 2951 set ref 2958* 2960* 2965* substr builtin function dcl 181 set ref 376* 376 380 479 492* 492 501 584 1254 1255* 1255 1256* 1431 1431 1723 1915 1935 2030 2063 2096* 2096 2098* 2139* 2139 2165* 2208* 2222* 2222 2240 2258 2374* 2380* 2380 2388* 2388 2388 2433 2451 2475* 2477* 2478* 2479* 2614 2629 3145 3145 3151 3151 3170 3394* suppress_echo 66(12) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 484 645 2195 3399 suppress_redisplay 5(05) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 131 in procedure "window_io_iox_" set ref 398* suppress_redisplay 5(05) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 612 in procedure "read_input_line" ref 688 suppress_redisplay 5(05) based bit(1) level 3 in structure "LEI" packed packed unaligned dcl 1268 in procedure "terminate_input_line" set ref 1272* t parameter char packed unaligned dcl 3023 in procedure "raw_write" set ref 3020 3034* t 000124 automatic pointer dcl 2840 in procedure "get_free_killer" set ref 2845* 2846 2846 2849 target_iocb_ptr 64 based pointer level 2 dcl 1-29 set ref 580* 2986* temp_char 000100 automatic char(1) packed unaligned dcl 1250 in procedure "twiddle_characters" set ref 1254* 1256 temp_char 000100 automatic char(1) packed unaligned dcl 2415 in procedure "scan_for_interesting_char" set ref 2422* 2424 2433* 2434 temp_char_varying 000100 automatic varying char(1) dcl 1302 in procedure "quote_character" set ref 1307* 1314 temp_char_varying 000102 automatic varying char(1) dcl 712 in procedure "process_break" set ref 747* 749 temp_count 001126 automatic fixed bin(21,0) dcl 2583 set ref 2614* 2616* temp_index 000102 automatic fixed bin(17,0) dcl 1303 set ref 1313* temp_ptr 000114 automatic pointer dcl 560 in procedure "free_user_data" set ref 565* 567 temp_ptr 000100 automatic pointer dcl 111 in procedure "window_io_iox_" set ref 249* 252 254 257 text parameter char packed unaligned dcl 2160 in procedure "add_to_window_image" ref 2157 2165 2165 text based char packed unaligned dcl 2723 in procedure "write_string" set ref 2726* text parameter char packed unaligned dcl 2410 in procedure "scan_for_interesting_char" ref 2407 2420 2422 2422 text parameter char packed unaligned dcl 2578 in procedure "put_out_chars" set ref 2575 2594 2598 2601* 2603 2614 2629 text parameter char packed unaligned dcl 2079 in procedure "insert_in_buffer" ref 2075 2091 2096 2098 2098 2099 2100 text 1 based varying char level 2 in structure "saved_buffer" dcl 138 in procedure "window_io_iox_" set ref 375 376 379 380* 380 501* text_length parameter fixed bin(17,0) dcl 2721 in procedure "write_string" ref 2717 2726 2726 text_length parameter fixed bin(21,0) dcl 2689 in procedure "write_with_continuation" ref 2685 2700 2710 text_ptr 001122 automatic pointer dcl 2580 in procedure "put_out_chars" set ref 2594* 2616* 2619* 2622* 2622 2627* 2627 text_ptr parameter pointer dcl 2688 in procedure "write_with_continuation" ref 2685 2697 text_ptr parameter pointer dcl 2720 in procedure "write_string" ref 2717 2726 text_to_add defined char packed unaligned dcl 2759 ref 2768 2795 2799 2801 the_nays defined char packed unaligned dcl 3198 ref 3203 the_yeas defined char packed unaligned dcl 3197 ref 3200 token_character_count 406 based fixed bin(17,0) level 2 dcl 1-29 ref 2024 2030 2057 2063 token_characters 407 based char(128) level 2 packed packed unaligned dcl 1-29 set ref 2024 2030 2057 2063 token_end_index 000101 automatic fixed bin(17,0) dcl 2047 in procedure "move_backward_word" set ref 2063* 2065 2067 token_end_index 000101 automatic fixed bin(17,0) dcl 2013 in procedure "move_forward_word" set ref 2030* 2032 2034 token_start_index 000100 automatic fixed bin(17,0) dcl 2046 in procedure "move_backward_word" set ref 2057* 2059 2063 2067 token_start_index 000100 automatic fixed bin(17,0) dcl 2012 in procedure "move_forward_word" set ref 2024* 2026 2030 2034 top_killer 164 based pointer level 3 dcl 1-29 set ref 1071 1328 1723 1723 1723 1723 1726 1727 1727 1732 2763 2768 2776 2789 2795 2795 2799 2799 2801 2801 2810* 2810 2822 2824* 2825 2825* 2828 2829 2830 2831 2831 2833 2885 2887 2889 2889 2892 2893 2896 2896 2899 2900 2903 2904* translate builtin function dcl 181 ref 1806 1808 1869 translation_idx 000106 automatic fixed bin(21,0) dcl 1345 set ref 1425* 1426 1431 1431 ttp_change 67(02) based bit(1) level 3 packed packed unaligned dcl 1-29 set ref 456 2924 type based fixed bin(17,0) array level 3 dcl 1-155 set ref 204* 205* 209* 212* 214* 215* 217* 218* 219* 221* 222* 224* 226* 227* 229* 230* 231* 232* 234* 236* 239* 240* 241* 252* 255* 261* 262* 263* 264* 265* 266* 267* 268* 269* 270* 271* 273* 274* 275* 276* 277* 278* 279* 280* 282* 283* 284* 285* 286* 287* 288* 289* 291* 292* 293* 317 732 745 753 753 786 unprocessed_char 000102 automatic varying char(1) dcl 1342 set ref 1371* 1372 1384* 1398 1398* unspec builtin function dcl 181 set ref 2473* 2473 uppercase 000067 constant char(26) initial packed unaligned dcl 163 ref 1806 1808 1869 uppercase_flag 000104 automatic bit(1) packed unaligned dcl 1774 set ref 1778* 1784* 1806 user_data_ptr 6 based pointer level 2 dcl 131 set ref 405* 535 535* valid_token_characters based char packed unaligned dcl 1-131 ref 2024 2030 2057 2063 verify builtin function dcl 181 ref 2030 2063 version 000100 automatic fixed bin(17,0) level 2 in structure "auto_window_position_info" dcl 2977 in procedure "resize_window" set ref 2995* version 000100 automatic fixed bin(17,0) level 2 in structure "b" dcl 517 in procedure "get_line_cleanup" set ref 529* version based char(8) level 2 in structure "window_edit_line_info" packed packed unaligned dcl 7-177 in procedure "window_io_iox_" ref 336 version 000105 automatic fixed bin(17,0) level 2 in structure "auto_capabilities_info" dcl 2979 in procedure "resize_window" set ref 2985* version based char(8) level 2 in structure "line_editor_info" dcl 5-8 in procedure "window_io_iox_" ref 1100 version 000162 automatic fixed bin(17,0) level 2 in structure "more_data" dcl 3096 in procedure "perform_more_break" set ref 3108* version based char(8) level 2 in structure "LEI" dcl 131 in procedure "window_io_iox_" set ref 393* vertsp 66(03) based bit(1) level 3 packed packed unaligned dcl 1-29 ref 2648 video_et_$capability_lacking 000026 external static fixed bin(35,0) dcl 168 ref 2550 video_et_$cursor_position_undefined 000024 external static fixed bin(35,0) dcl 168 ref 460 video_et_$out_of_window_bounds 000022 external static fixed bin(35,0) dcl 168 ref 2943 video_et_$window_status_pending 000020 external static fixed bin(35,0) dcl 168 ref 455 2916 3129 3180 width 3 000100 automatic fixed bin(17,0) level 3 dcl 2977 set ref 2991* 2999* window_$bell 000036 constant entry external dcl 6-6 ref 735 1404 3061 window_$clear_to_end_of_line 000040 constant entry external dcl 6-9 ref 3050 window_$clear_to_end_of_window 000042 constant entry external dcl 6-11 ref 2656 window_$clear_window 000044 constant entry external dcl 6-13 ref 2557 2928 2964 window_$get_echoed_chars 000046 constant entry external dcl 6-22 ref 651 window_$get_one_unechoed 000066 constant entry external dcl 6-67 ref 634 645 747 1307 1360 1373 1620 window_$get_one_unechoed_char 000070 constant entry external dcl 6-67 ref 3384 window_$overwrite_text 000050 constant entry external dcl 6-29 ref 2726 3236 3260 3269 window_$position_cursor 000052 constant entry external dcl 6-31 ref 462 2294 2538 2553 2562 2658 2669 3222 3227 3233 3251 3257 3266 3346 window_$position_cursor_rel 000054 constant entry external dcl 6-36 ref 454 window_$scroll_region 000056 constant entry external dcl 6-42 ref 2308 2548 window_$sync 000060 constant entry external dcl 6-44 ref 508 3244 3353 window_$write_raw_text 000062 constant entry external dcl 6-48 ref 3034 window_$write_sync_read 000064 constant entry external dcl 6-53 ref 3173 window_display_ 000106 constant entry external dcl 2193 ref 2265 window_edit_line_info based structure level 1 unaligned dcl 7-177 window_edit_line_info_ptr 000440 automatic pointer dcl 7-186 set ref 334* 336 341 351* 410 411 414 414 414 418* window_edit_line_info_version_1 000054 constant char(8) initial packed unaligned dcl 7-183 ref 336 window_image based char array packed unaligned dcl 1-135 set ref 584* 1998* 2165* 2208* 2213* 2222* 2240* 2258* 2265* 2304* 2304 window_image_ptr 450 based pointer level 2 dcl 1-29 ref 584 1998 2165 2208 2213 2222 2240 2258 2265 2304 2304 window_iocb_ptr 2 000162 automatic pointer level 2 dcl 3096 set ref 3109* window_line_used_ptr 000122 automatic pointer dcl 126 set ref 434* 439* 522 522 589 1999 2166 2209 2212 2214 2223 2241 2260 2305 2305 window_position_info based structure level 1 unaligned dcl 7-25 window_position_info_version_1 constant fixed bin(17,0) initial dcl 7-35 ref 2995 window_status 000436 automatic structure level 1 dcl 3-10 window_width 000107 automatic fixed bin(17,0) dcl 2187 set ref 2204* 2221 2229* 2229 2231 2240 2242 2274 word 000100 automatic char packed unaligned dcl 1914 in begin block on line 1913 set ref 1915* 1947 1947 word defined char packed unaligned dcl 1804 in begin block on line 1803 set ref 1806* 1806 1808* 1808 word2 000100 automatic char packed unaligned dcl 1934 set ref 1935* 1938 1938 words 5 based varying char level 2 dcl 1-118 set ref 1071 1328 1723 1723 1723 1723 1726 1727 1727 1732 2768 2789 2795 2795 2799* 2799 2801* 2801 2833* 2860* 2887* 2887 yesses_string 000126 automatic varying char(40) dcl 3089 set ref 3143* 3145* 3145 3146* 3146 3155* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 13-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 13-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 13-7 BUILTIN_INFO_DIR internal static char(168) initial packed unaligned dcl 2-138 BUILTIN_INFO_ENTRY internal static char(32) initial packed unaligned dcl 2-139 CV_TRANS_SIZE internal static fixed bin(17,0) initial array dcl 10-129 CV_TRANS_VERSION internal static fixed bin(17,0) initial dcl 10-127 DELAY_VERSION internal static fixed bin(17,0) initial dcl 10-126 EXTERNAL_ROUTINE internal static fixed bin(17,0) initial dcl 2-13 HIGHEST_BUILTIN_ROUTINE_VALUE internal static fixed bin(17,0) initial dcl 2-13 HIGHEST_NUMARG_ACTION_VALUE internal static fixed bin(17,0) initial dcl 2-143 INPUT_CONVERT_BREAK internal static fixed bin(8,0) initial packed unaligned dcl 10-135 INPUT_CONVERT_DISCARD internal static fixed bin(8,0) initial packed unaligned dcl 10-135 INPUT_CONVERT_DSA_CR_PROCESSING internal static fixed bin(8,0) initial packed unaligned dcl 10-135 INPUT_CONVERT_ESCAPE internal static fixed bin(8,0) initial packed unaligned dcl 10-135 INPUT_CONVERT_FORMFEED internal static fixed bin(8,0) initial packed unaligned dcl 10-135 INPUT_CONVERT_ORDINARY internal static fixed bin(8,0) initial packed unaligned dcl 10-135 INPUT_CONVERT_PRECEDENCE_DISCARD internal static fixed bin(8,0) initial packed unaligned dcl 10-135 MORE_MODE_CLEAR internal static fixed bin(17,0) initial dcl 1-106 OUTPUT_CONVERT_DONT_SEND internal static fixed bin(8,0) initial packed unaligned dcl 10-147 OUTPUT_CONVERT_NOT_USED_13 internal static fixed bin(8,0) initial packed unaligned dcl 10-147 OUTPUT_CONVERT_NOT_USED_14 internal static fixed bin(8,0) initial packed unaligned dcl 10-147 OUTPUT_CONVERT_NOT_USED_15 internal static fixed bin(8,0) initial packed unaligned dcl 10-147 OUTPUT_CONVERT_NOT_USED_16 internal static fixed bin(8,0) initial packed unaligned dcl 10-147 OUTPUT_CONVERT_NO_MOTION internal static fixed bin(8,0) initial packed unaligned dcl 10-147 OUTPUT_CONVERT_PRECEDENCE_NO_MOTION internal static fixed bin(8,0) initial packed unaligned dcl 10-147 SPECIAL_INFO_STRUCT_VERSION_1 internal static char(8) initial packed unaligned dcl 10-122 SPECIAL_VERSION internal static fixed bin(17,0) initial dcl 10-124 SPECIAL_VERSION_2 internal static fixed bin(17,0) initial dcl 10-125 W_STATUS_ASYNC_EVENT internal static bit(36) initial dcl 3-17 W_STATUS_RECONNECTION internal static bit(36) initial dcl 3-17 W_STATUS_SCREEN_INVALID internal static bit(36) initial dcl 3-17 W_STATUS_TTP_CHANGE internal static bit(36) initial dcl 3-17 break_table_info_version_1 internal static fixed bin(17,0) initial dcl 7-80 break_table_ptr automatic pointer dcl 7-75 breaks_array defined bit(1) array packed unaligned dcl 1-127 builtin_descriptions internal static varying char(128) initial array dcl 2-105 builtin_routine_names internal static char(32) initial array packed unaligned dcl 2-63 c_chars_ptr automatic pointer dcl 10-53 capabilities_info_ptr automatic pointer dcl 4-19 capabilities_info_version internal static fixed bin(17,0) initial dcl 4-17 cv_trans_struc based structure level 1 dcl 10-107 delay_struc based structure level 1 dcl 10-112 get_editor_key_bindings_info based structure level 1 dcl 7-151 get_editor_key_bindings_info_ptr automatic pointer dcl 7-159 get_editor_key_bindings_info_version_1 internal static char(8) initial packed unaligned dcl 7-160 get_special_info_struc based structure level 1 dcl 10-117 iox_$attach_loud 000000 constant entry external dcl 11-8 iox_$attach_name 000000 constant entry external dcl 11-8 iox_$attach_ptr 000000 constant entry external dcl 11-8 iox_$close 000000 constant entry external dcl 11-8 iox_$close_file 000000 constant entry external dcl 11-8 iox_$delete_record 000000 constant entry external dcl 11-8 iox_$destroy_iocb 000000 constant entry external dcl 11-8 iox_$detach 000000 constant entry external dcl 11-8 iox_$detach_iocb 000000 constant entry external dcl 11-8 iox_$err_no_operation 000000 constant entry external dcl 11-8 iox_$err_not_attached 000000 constant entry external dcl 11-8 iox_$err_not_closed 000000 constant entry external dcl 11-8 iox_$err_not_open 000000 constant entry external dcl 11-8 iox_$error_output external static pointer dcl 11-41 iox_$find_iocb 000000 constant entry external dcl 11-8 iox_$find_iocb_n 000000 constant entry external dcl 11-8 iox_$get_chars 000000 constant entry external dcl 11-8 iox_$get_line 000000 constant entry external dcl 11-8 iox_$iocb_version_sentinel external static char(4) dcl 12-51 iox_$look_iocb 000000 constant entry external dcl 11-8 iox_$modes 000000 constant entry external dcl 11-8 iox_$move_attach 000000 constant entry external dcl 11-8 iox_$open 000000 constant entry external dcl 11-8 iox_$open_file 000000 constant entry external dcl 11-8 iox_$position 000000 constant entry external dcl 11-8 iox_$propagate 000000 constant entry external dcl 11-8 iox_$read_key 000000 constant entry external dcl 11-8 iox_$read_length 000000 constant entry external dcl 11-8 iox_$read_record 000000 constant entry external dcl 11-8 iox_$rewrite_record 000000 constant entry external dcl 11-8 iox_$seek_key 000000 constant entry external dcl 11-8 iox_$user_input external static pointer dcl 11-41 iox_$user_io external static pointer dcl 11-41 iox_$user_output external static pointer dcl 11-41 iox_$write_record 000000 constant entry external dcl 11-8 line_editor_binding_count automatic fixed bin(17,0) dcl 7-121 line_editor_breaks_array defined bit(1) array packed unaligned dcl 1-128 line_editor_info_ptr automatic pointer dcl 5-6 line_editor_info_version_1 internal static char(8) initial packed unaligned dcl 5-28 line_editor_input_line based char packed unaligned dcl 5-26 line_editor_key_binding_info based structure level 1 dcl 7-129 line_editor_key_binding_info_ptr automatic pointer dcl 7-118 line_editor_key_binding_info_version_3 internal static char(8) initial packed unaligned dcl 7-148 line_editor_longest_sequence automatic fixed bin(17,0) dcl 7-123 more_handler_info based structure level 1 dcl 7-83 more_handler_info_ptr automatic pointer dcl 7-92 more_handler_info_version internal static fixed bin(17,0) initial dcl 7-94 more_handler_info_version_3 internal static fixed bin(17,0) initial dcl 7-94 more_info_ptr automatic pointer dcl 8-3 more_info_version_2 internal static fixed bin(17,0) initial dcl 8-16 more_prompt_info based structure level 1 dcl 7-108 more_prompt_info_ptr automatic pointer dcl 7-112 more_prompt_info_version_1 internal static char(8) initial packed unaligned dcl 7-114 more_responses_info based structure level 1 dcl 7-59 more_responses_info_ptr automatic pointer dcl 7-69 more_responses_info_version_1 internal static fixed bin(17,0) initial dcl 7-67 more_responses_version internal static fixed bin(17,0) initial dcl 7-67 numarg_action_names internal static char(6) initial array packed unaligned dcl 2-154 sc_escape_len automatic fixed bin(17,0) dcl 10-58 sc_input_escape_len automatic fixed bin(17,0) dcl 10-59 screen_n_columns automatic fixed bin(17,0) dcl 9-13 screen_n_lines automatic fixed bin(17,0) dcl 9-13 set_editor_key_bindings_info based structure level 1 dcl 7-162 set_editor_key_bindings_info_ptr automatic pointer dcl 7-171 set_editor_key_bindings_info_version_1 internal static char(8) initial packed unaligned dcl 7-172 special_chars_struc based structure level 1 dcl 10-76 token_characters_info based structure level 1 dcl 7-97 token_characters_info_ptr automatic pointer dcl 7-104 token_characters_info_version_1 internal static char(8) initial packed unaligned dcl 7-106 window_$change_column 000000 constant entry external dcl 6-63 window_$change_line 000000 constant entry external dcl 6-59 window_$clear_region 000000 constant entry external dcl 6-7 window_$create 000000 constant entry external dcl 6-72 window_$delete_chars 000000 constant entry external dcl 6-15 window_$destroy 000000 constant entry external dcl 6-74 window_$edit_line 000000 constant entry external dcl 6-76 window_$get_cursor_position 000000 constant entry external dcl 6-17 window_$get_unechoed_chars 000000 constant entry external dcl 6-25 window_$insert_text 000000 constant entry external dcl 6-28 window_image_string based char packed unaligned dcl 1-139 window_position_info_ptr automatic pointer dcl 7-37 window_position_info_version internal static fixed bin(17,0) initial dcl 7-35 window_status_info based structure level 1 dcl 7-45 window_status_info_ptr automatic pointer dcl 7-43 window_status_string automatic bit(36) packed unaligned dcl 3-7 window_status_version internal static fixed bin(17,0) initial dcl 7-52 window_status_version_1 internal static fixed bin(17,0) initial dcl 7-52 NAMES DECLARED BY EXPLICIT CONTEXT. ABORT_OUTPUT 017107 constant label dcl 3220 ref 3138 3216 CONTINUE_OUTPUT 017335 constant label dcl 3249 ref 3136 3213 Error_Detector 015531 constant entry internal dcl 2908 GET_LINE_COMMON 001336 constant label dcl 353 set ref 346 RESTART_GET_LINE 002055 constant label dcl 543 ref 444 RESTART_PUT_CHARS 002635 constant label dcl 3357 ref 3340 RESTART_PUT_RAW_CHARS 002527 constant label dcl 3334 ref 3334 RETURN 002444 constant label dcl 2973 ref 3306 abort_output 017712 constant entry internal dcl 3301 ref 3247 add_to_kill_ring 015012 constant entry internal dcl 2746 ref 484 2135 add_to_window_image 012030 constant entry internal dcl 2157 ref 676 alloc_killer 015313 constant entry internal dcl 2852 ref 2825 async_or_error 015540 constant entry internal dcl 2908 ref 463 581 635 659 736 748 1308 1361 1374 1405 1622 2266 2295 2309 2540 2552 2554 2559 2565 2657 2659 2670 2727 2987 3016 3035 3051 3062 3134 3186 3223 3228 3234 3237 3245 3252 3258 3261 3267 3270 3347 backward_character 005203 constant entry internal dcl 1164 ref 813 backward_delete_character 005104 constant entry internal dcl 1129 ref 823 backward_delete_word 007764 constant entry internal dcl 1693 ref 863 backward_word 007653 constant entry internal dcl 1650 ref 853 1063 builtin_requests 000000 constant label array(38) dcl 808 ref 753 case_common 010236 constant label dcl 1786 ref 1779 check_more 016253 constant entry internal dcl 3067 ref 2725 cl_pusher 017724 constant entry internal dcl 3409 ref 450 450 clear_to_end_of_line 016176 constant entry internal dcl 3045 ref 2541 2566 3224 3229 3235 3253 3259 3268 3350 clear_window 005475 constant entry internal dcl 1281 ref 873 clear_window_image 011414 constant entry internal dcl 1995 ref 1288 common_delete 011752 constant label dcl 2127 ref 2120 convert_char 013456 constant entry internal dcl 2438 ref 2388 2630 convert_octal_rep 013526 constant label dcl 2459 ref 2513 convert_special_sequence 014000 constant entry internal dcl 2515 ref 2491 2496 2501 2507 delete_from_buffer 011725 constant entry internal dcl 2106 ref 1015 1140 1225 1390 1407 1415 1428 1727 1917 1944 delete_from_buffer_save 011740 constant entry internal dcl 2122 ref 1023 1159 1238 1688 1708 delete_text_ 002145 constant entry external dcl 1010 delete_text_save_ 002177 constant entry external dcl 1018 display_editor_documentation 010154 constant entry internal dcl 1741 ref 883 do_editor_request 004116 constant label dcl 760 ref 811 816 821 826 831 836 841 846 851 856 861 866 871 876 881 886 891 896 901 906 911 916 921 926 931 936 941 946 951 956 961 966 971 976 981 986 991 996 edit_line 001250 constant entry external dcl 328 editor_request_finish 004252 constant label dcl 799 ref 765 773 783 expand_kill_ring_element 015377 constant entry internal dcl 2880 ref 2796 flat_rep 017620 constant entry internal dcl 3280 ref 3145 3151 forward_character 005223 constant entry internal dcl 1178 ref 808 forward_delete_character 005276 constant entry internal dcl 1218 ref 818 forward_delete_word 007713 constant entry internal dcl 1672 ref 858 forward_word 007673 constant entry internal dcl 1661 ref 848 1055 free_dispatch_tables 001204 constant entry external dcl 313 ref 306 317 free_killer 015352 constant entry internal dcl 2864 ref 2782 free_user_data 003160 constant entry internal dcl 555 ref 535 get_chars 002662 constant entry external dcl 3367 get_current_word_info 011276 constant entry internal dcl 1959 ref 1801 1865 1904 1910 get_free_killer 015275 constant entry internal dcl 2837 ref 2824 get_input_line 001725 constant label dcl 473 ref 552 get_line 001316 constant entry external dcl 348 get_line_cleanup 003022 constant entry internal dcl 514 ref 436 510 get_more 007430 constant label dcl 1620 ref 1629 1641 get_to_next_line 014021 constant entry internal dcl 2530 ref 543 690 1277 2635 2652 2702 3121 3163 3239 3262 3271 3274 get_top_kill_ring_element_ 002373 constant entry external dcl 1066 init 000305 constant entry external dcl 192 initial_capital 010446 constant entry internal dcl 1834 ref 983 initialize_window_image 003210 constant entry internal dcl 574 ref 616 1761 insert_in_buffer 011640 constant entry internal dcl 2075 ref 414 671 1007 1123 1125 1276 1314 1328 1354 1366 1378 1393 1418 1431 1438 1732 1938 1947 insert_new_kill_ring_element 015227 constant entry internal dcl 2817 ref 2789 insert_text_ 002077 constant entry external dcl 1002 kill_to_beginning_of_line 005144 constant entry internal dcl 1146 ref 843 kill_to_end_of_line 005324 constant entry internal dcl 1229 ref 838 lowercase_word 010217 constant entry internal dcl 1766 ref 973 1861 more_type 000046 constant label array(4) dcl 2548 ref 2546 2550 move_backward_ 002265 constant entry external dcl 1038 move_backward_word 011551 constant entry internal dcl 2041 ref 1657 1706 1824 1825 1884 1885 1921 1976 1985 move_backward_word_ 002346 constant entry external dcl 1058 move_forward_ 002230 constant entry external dcl 1026 move_forward_word 011463 constant entry internal dcl 2007 ref 1668 1685 1812 1813 1826 1872 1873 1886 1908 1909 1927 1951 1973 1980 1987 move_forward_word_ 002321 constant entry external dcl 1050 move_to_beginning_of_line 005243 constant entry internal dcl 1192 ref 833 move_to_end_of_line 005260 constant entry internal dcl 1205 ref 828 moved 014246 constant label dcl 2568 ref 2555 2560 multiplier 007314 constant entry internal dcl 1572 ref 968 negative_number_reader 007360 constant entry internal dcl 1591 ref 993 nulle 000315 constant entry external dcl 192 ref 431 525 number_reader_0 006726 constant entry internal dcl 1444 ref 918 number_reader_1 006752 constant entry internal dcl 1455 ref 923 number_reader_2 006777 constant entry internal dcl 1466 ref 928 number_reader_3 007024 constant entry internal dcl 1477 ref 933 number_reader_4 007051 constant entry internal dcl 1488 ref 938 number_reader_5 007076 constant entry internal dcl 1499 ref 943 number_reader_6 007123 constant entry internal dcl 1510 ref 948 number_reader_7 007150 constant entry internal dcl 1521 ref 953 number_reader_8 007175 constant entry internal dcl 1532 ref 958 number_reader_9 007222 constant entry internal dcl 1543 ref 963 number_reader_common 007247 constant entry internal dcl 1554 ref 1450 1461 1472 1483 1494 1505 1516 1527 1538 1549 output_convert_one_character 013417 constant entry internal dcl 2428 perform_more_break 016312 constant entry internal dcl 3084 ref 3082 perform_output_conversions 013015 constant entry internal dcl 2329 ref 2201 process_break 003715 constant entry internal dcl 705 ref 686 1398 1644 process_input_escape 005705 constant entry internal dcl 1333 ref 913 put_chars 002473 constant entry external dcl 3320 put_chars_return 002622 constant label dcl 3353 ref 3337 3364 put_out_chars 014247 constant entry internal dcl 2575 ref 3351 3362 quote_character 005513 constant entry internal dcl 1294 ref 868 raw_write 016120 constant entry internal dcl 3020 ref 2668 3336 read_input_line 003344 constant entry internal dcl 597 ref 473 read_numbers_then_dispatch 007416 constant entry internal dcl 1606 ref 1566 1586 1601 recheck_more 016254 constant label dcl 3070 ref 3132 3184 redisplay_input_line 012067 constant entry internal dcl 2175 ref 618 689 696 1275 1358 1369 1382 reset_more_entry 002447 constant entry external dcl 3310 resize_window 015731 constant entry internal dcl 2975 ref 456 2924 2945 return_from_get_line 002050 constant label dcl 510 ref 467 ring 016225 constant entry internal dcl 3056 ref 673 799 908 1792 1817 1850 1877 2644 3208 rotate_kill_ring 015214 constant entry internal dcl 2807 ref 1079 1731 rotate_kill_ring_ 002426 constant entry external dcl 1074 scan_for_interesting_char 013326 constant entry internal dcl 2407 ref 2359 2601 scroll_window_image 012700 constant entry internal dcl 2298 ref 2235 2253 self_insert 004777 constant entry internal dcl 1115 ref 888 setup_util_call 004744 constant entry internal dcl 1087 ref 1005 1013 1021 1030 1042 1053 1061 1069 1077 shut 001144 constant entry external dcl 300 terminate_input_line 005413 constant entry internal dcl 1262 ref 903 twiddle_characters 005360 constant entry internal dcl 1242 ref 878 twiddle_words 010656 constant entry internal dcl 1892 ref 988 uppercase_word 010227 constant entry internal dcl 1781 ref 978 util_call_return 002443 constant label dcl 1081 ref 1097 1102 verify_response 017033 constant label dcl 3194 window_io_iox_ 000274 constant entry external dcl 12 write_string 014751 constant entry internal dcl 2717 ref 2701 2703 2711 write_with_continuation 014665 constant entry internal dcl 2685 ref 2616 2619 2678 yank_from_kill_ring 005632 constant entry internal dcl 1319 ref 893 yank_previous_from_kill_ring 010033 constant entry internal dcl 1712 ref 898 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 22314 22434 20453 22324 Length 23420 20453 120 750 1640 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME window_io_iox_ 838 external procedure is an external procedure. begin block on line 412 begin block shares stack frame of external procedure window_io_iox_. on unit on line 436 64 on unit get_line_cleanup 108 internal procedure is called by several nonquick procedures. free_user_data internal procedure shares stack frame of internal procedure get_line_cleanup. initialize_window_image 95 internal procedure is called by several nonquick procedures. read_input_line internal procedure shares stack frame of external procedure window_io_iox_. begin block on line 669 begin block shares stack frame of external procedure window_io_iox_. process_break 96 internal procedure is called by several nonquick procedures. setup_util_call internal procedure shares stack frame of external procedure window_io_iox_. self_insert 84 internal procedure is assigned to an entry variable. backward_delete_character 76 internal procedure is assigned to an entry variable. kill_to_beginning_of_line 78 internal procedure is assigned to an entry variable. backward_character 64 internal procedure is assigned to an entry variable. forward_character 64 internal procedure is assigned to an entry variable. move_to_beginning_of_line 64 internal procedure is assigned to an entry variable. move_to_end_of_line 64 internal procedure is assigned to an entry variable. forward_delete_character 76 internal procedure is assigned to an entry variable. kill_to_end_of_line 78 internal procedure is assigned to an entry variable. twiddle_characters 65 internal procedure is assigned to an entry variable. terminate_input_line 86 internal procedure is assigned to an entry variable. clear_window 74 internal procedure is assigned to an entry variable. quote_character 98 internal procedure is assigned to an entry variable. yank_from_kill_ring 84 internal procedure is assigned to an entry variable. process_input_escape 253 internal procedure is assigned to an entry variable. number_reader_0 76 internal procedure is assigned to an entry variable. number_reader_1 76 internal procedure is assigned to an entry variable. number_reader_2 76 internal procedure is assigned to an entry variable. number_reader_3 76 internal procedure is assigned to an entry variable. number_reader_4 76 internal procedure is assigned to an entry variable. number_reader_5 76 internal procedure is assigned to an entry variable. number_reader_6 76 internal procedure is assigned to an entry variable. number_reader_7 76 internal procedure is assigned to an entry variable. number_reader_8 76 internal procedure is assigned to an entry variable. number_reader_9 76 internal procedure is assigned to an entry variable. number_reader_common 78 internal procedure is called by several nonquick procedures. multiplier 78 internal procedure is assigned to an entry variable. negative_number_reader 78 internal procedure is assigned to an entry variable. read_numbers_then_dispatch 254 internal procedure is called by several nonquick procedures. backward_word 70 internal procedure is assigned to an entry variable. forward_word 70 internal procedure is assigned to an entry variable. forward_delete_word 84 internal procedure is assigned to an entry variable. backward_delete_word 84 internal procedure is assigned to an entry variable. yank_previous_from_kill_ring 94 internal procedure is assigned to an entry variable. display_editor_documentation 106 internal procedure is assigned to an entry variable. lowercase_word 82 internal procedure is assigned to an entry variable. begin block on line 1803 begin block shares stack frame of internal procedure lowercase_word. initial_capital 89 internal procedure is assigned to an entry variable. begin block on line 1867 begin block shares stack frame of internal procedure initial_capital. twiddle_words 78 internal procedure is assigned to an entry variable. begin block on line 1913 98 begin block uses auto adjustable storage. begin block on line 1933 88 begin block uses auto adjustable storage. get_current_word_info 70 internal procedure is called by several nonquick procedures. clear_window_image internal procedure shares stack frame of internal procedure clear_window. move_forward_word 69 internal procedure is called by several nonquick procedures. begin block on line 2017 begin block shares stack frame of internal procedure move_forward_word. move_backward_word 70 internal procedure is called by several nonquick procedures. begin block on line 2051 begin block shares stack frame of internal procedure move_backward_word. insert_in_buffer 67 internal procedure is called during a stack extension. delete_from_buffer 80 internal procedure is called by several nonquick procedures. add_to_window_image internal procedure shares stack frame of external procedure window_io_iox_. redisplay_input_line 204 internal procedure is called by several nonquick procedures. scroll_window_image internal procedure shares stack frame of internal procedure redisplay_input_line. perform_output_conversions internal procedure shares stack frame of internal procedure redisplay_input_line. begin block on line 2356 begin block shares stack frame of internal procedure redisplay_input_line. scan_for_interesting_char 90 internal procedure is called by several nonquick procedures. convert_char 92 internal procedure is called by several nonquick procedures. begin block on line 2459 begin block shares stack frame of internal procedure convert_char. convert_special_sequence internal procedure shares stack frame of internal procedure convert_char. get_to_next_line 88 internal procedure is called by several nonquick procedures. put_out_chars internal procedure shares stack frame of external procedure window_io_iox_. write_with_continuation internal procedure shares stack frame of external procedure window_io_iox_. write_string internal procedure shares stack frame of external procedure window_io_iox_. add_to_kill_ring 132 internal procedure is called by several nonquick procedures. rotate_kill_ring 64 internal procedure is called by several nonquick procedures. insert_new_kill_ring_element internal procedure shares stack frame of internal procedure add_to_kill_ring. get_free_killer internal procedure shares stack frame of internal procedure add_to_kill_ring. alloc_killer internal procedure shares stack frame of internal procedure add_to_kill_ring. free_killer internal procedure shares stack frame of internal procedure add_to_kill_ring. expand_kill_ring_element internal procedure shares stack frame of internal procedure add_to_kill_ring. Error_Detector 108 internal procedure is called by several nonquick procedures. begin block on line 2949 begin block shares stack frame of internal procedure Error_Detector. resize_window 98 internal procedure is called by several nonquick procedures. raw_write 80 internal procedure is called during a stack extension. clear_to_end_of_line 72 internal procedure is called by several nonquick procedures. ring 72 internal procedure is assigned to an entry variable. check_more internal procedure shares stack frame of external procedure window_io_iox_. perform_more_break 248 internal procedure enables or reverts conditions. on unit on line 3118 70 on unit on unit on line 3160 70 on unit begin block on line 3194 begin block shares stack frame of internal procedure perform_more_break. flat_rep internal procedure shares stack frame of internal procedure perform_more_break. abort_output internal procedure shares stack frame of internal procedure perform_more_break. begin block on line 3357 begin block shares stack frame of external procedure window_io_iox_. cl_pusher 70 internal procedure is assigned to an entry variable. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME Error_Detector 000100 sub_err_action begin block on line 2949 add_to_kill_ring 000100 killer_count add_to_kill_ring 000102 current_killer add_to_kill_ring 000114 k insert_new_kill_ring_element 000124 t get_free_killer 000134 new alloc_killer 000152 k expand_kill_ring_element backward_delete_word 000100 count backward_delete_word 000101 old_cursor backward_delete_word begin block on line 1913 000100 word begin block on line 1913 begin block on line 1933 000100 word2 begin block on line 1933 clear_to_end_of_line 000100 code clear_to_end_of_line convert_char 000100 octal_rep begin block on line 2459 000101 decomp begin block on line 2459 delete_from_buffer 000100 save_on_kill_ring delete_from_buffer 000101 move_count delete_from_buffer forward_delete_word 000100 count forward_delete_word 000101 old_cursor forward_delete_word get_line_cleanup 000100 b get_line_cleanup 000114 temp_ptr free_user_data initial_capital 000100 start initial_capital 000101 end initial_capital 000102 i initial_capital 000103 repeat_count initial_capital initialize_window_image 000100 line_idx initialize_window_image 000101 code initialize_window_image insert_in_buffer 000100 copy_count insert_in_buffer kill_to_beginning_of_line 000100 old_cursor kill_to_beginning_of_line lowercase_word 000100 start lowercase_word 000101 end lowercase_word 000102 i lowercase_word 000103 repeat_count lowercase_word 000104 uppercase_flag lowercase_word move_backward_word 000100 token_start_index move_backward_word 000101 token_end_index move_backward_word move_forward_word 000100 token_start_index move_forward_word 000101 token_end_index move_forward_word perform_more_break 000100 continue_output perform_more_break 000101 prompt perform_more_break 000126 yesses_string perform_more_break 000141 noes_string perform_more_break 000154 i perform_more_break 000155 got_response perform_more_break 000156 response perform_more_break 000157 r perform_more_break 000160 break perform_more_break 000162 more_data perform_more_break process_break 000100 break process_break 000102 temp_char_varying process_break 000104 code process_break 000105 i process_break 000106 repeat_count process_break 000107 numarg_action process_break 000110 editor_routine process_break process_input_escape 000100 input_char process_input_escape 000102 unprocessed_char process_input_escape 000104 count process_input_escape 000105 escape_index process_input_escape 000106 translation_idx process_input_escape 000107 result process_input_escape quote_character 000100 temp_char_varying quote_character 000102 temp_index quote_character 000103 repeat_count quote_character raw_write 000100 code raw_write read_numbers_then_dispatch 000100 next_char read_numbers_then_dispatch redisplay_input_line 000100 converted_cursor redisplay_input_line 000101 converted_length redisplay_input_line 000102 last_character_line redisplay_input_line 000103 last_character_column redisplay_input_line 000104 cursor_line redisplay_input_line 000105 cursor_column redisplay_input_line 000106 line redisplay_input_line 000107 window_width redisplay_input_line 000110 processed redisplay_input_line 000111 line_offset redisplay_input_line 000126 line scroll_window_image 000136 char_index perform_output_conversions 000137 char_type perform_output_conversions 000140 start perform_output_conversions 000141 chars_seen perform_output_conversions 000142 converted_length perform_output_conversions resize_window 000100 auto_window_position_info resize_window 000105 auto_capabilities_info resize_window ring 000100 code ring scan_for_interesting_char 000100 temp_char scan_for_interesting_char twiddle_characters 000100 temp_char twiddle_characters twiddle_words 000100 start twiddle_words 000101 end twiddle_words 000102 start2 twiddle_words 000103 end2 twiddle_words window_io_iox_ 000100 temp_ptr window_io_iox_ 000102 key_idx window_io_iox_ 000103 get_line_entry_line window_io_iox_ 000104 get_line_entry_column window_io_iox_ 000106 iocb_ptr window_io_iox_ 000110 number_to_save window_io_iox_ 000112 char_varying window_io_iox_ 000114 char_nonvarying window_io_iox_ 000115 char_count window_io_iox_ 000116 code window_io_iox_ 000120 redisplay_buffer_ptr window_io_iox_ 000122 window_line_used_ptr window_io_iox_ 000124 lei_ptr window_io_iox_ 000126 automatic_line_editor_info window_io_iox_ 000400 saved_buffer_length window_io_iox_ 000402 REAL_CL_INTERMEDIARY window_io_iox_ 000406 BREAKS_CHANGED window_io_iox_ 000407 SAVED_BREAKS window_io_iox_ 000414 ASYNC_EVENT window_io_iox_ 000420 ERROR_COUNT window_io_iox_ 000421 PROCESSED_SO_FAR window_io_iox_ 000430 attach_data_ptr window_io_iox_ 000432 killer_alloc_size window_io_iox_ 000434 dispatch_table_ptr window_io_iox_ 000436 window_status window_io_iox_ 000440 window_edit_line_info_ptr window_io_iox_ 000442 screen_ptr window_io_iox_ 000466 break_char read_input_line 000470 number_returned read_input_line 000471 number_to_read read_input_line 000472 read_start_line read_input_line 000473 read_start_column read_input_line 000474 code read_input_line 000475 read_buffer read_input_line 001122 text_ptr put_out_chars 001124 line_left put_out_chars 001125 ordinary_count put_out_chars 001126 temp_count put_out_chars 001127 interesting_char_index put_out_chars 001130 interesting_char_type put_out_chars 001131 interesting_char put_out_chars 001132 char_rep put_out_chars 001143 char_temp put_out_chars 001153 char_rep_length put_out_chars 001154 saved_line put_out_chars 001155 saved_column put_out_chars 001164 chars_left_to_write write_with_continuation 001165 start_idx write_with_continuation 001166 start_ptr write_with_continuation THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp enter_begin_block leave_begin_block call_ent_var call_ext_in call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other begin_return_mac return_mac move_label_var make_label_var tra_ext_1 tra_ext_2 alloc_auto_adj sign_mac mpfx2 mdfx1 signal_op enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc repeat reverse_cs set_chars_eis index_chars_eis verify_eis search_eis any_to_any_truncate_ op_alloc_ alloc_storage op_freen_ search_rev_chars THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. continue_to_signal_ cu_$get_cl_intermediary cu_$set_cl_intermediary find_char_$translate_first_in_table freen_ get_system_free_area_ ioa_ ioa_$rsnnl iox_$control iox_$put_chars sub_err_ window_$bell window_$clear_to_end_of_line window_$clear_to_end_of_window window_$clear_window window_$get_echoed_chars window_$get_one_unechoed window_$get_one_unechoed_char window_$overwrite_text window_$position_cursor window_$position_cursor_rel window_$scroll_region window_$sync window_$write_raw_text window_$write_sync_read window_display_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$bad_subr_arg error_table_$long_record error_table_$null_info_ptr error_table_$unimplemented_version error_table_$unimplemented_version video_et_$capability_lacking video_et_$cursor_position_undefined video_et_$out_of_window_bounds video_et_$window_status_pending LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000273 15 000301 192 000302 196 000322 197 000327 199 000331 201 000333 204 000337 205 000356 208 000361 209 000367 210 000373 212 000375 214 000400 215 000402 217 000404 218 000406 219 000410 221 000412 222 000414 224 000416 226 000420 227 000422 229 000424 230 000426 231 000430 232 000432 234 000434 236 000436 239 000441 240 000450 241 000456 243 000464 246 000543 249 000546 252 000552 254 000570 255 000572 257 000574 261 000575 262 000603 263 000611 264 000617 265 000625 266 000633 267 000641 268 000647 269 000655 270 000663 271 000671 273 000677 274 000705 275 000713 276 000721 277 000727 278 000735 279 000743 280 000751 282 000757 283 000765 284 000773 285 001001 286 001007 287 001015 288 001023 289 001031 291 001037 292 001045 293 001053 295 001062 298 001141 300 001142 303 001151 304 001156 306 001160 308 001166 311 001201 313 001202 316 001211 317 001215 319 001234 321 001236 323 001241 328 001242 334 001266 336 001272 337 001276 338 001301 341 001302 342 001304 343 001307 346 001310 348 001311 351 001334 353 001336 355 001343 357 001345 358 001346 361 001347 365 001351 367 001352 374 001360 375 001364 376 001372 379 001377 380 001402 381 001414 382 001417 384 001420 385 001426 387 001431 391 001432 393 001434 394 001437 395 001440 396 001442 397 001444 398 001446 399 001450 400 001451 401 001453 402 001456 403 001460 404 001462 405 001464 410 001466 411 001471 414 001474 415 001520 417 001524 418 001527 425 001531 426 001534 428 001536 429 001537 430 001540 431 001543 433 001547 434 001551 436 001552 439 001574 440 001603 444 001607 449 001612 450 001621 454 001633 455 001652 456 001656 457 001666 458 001671 459 001672 460 001673 462 001675 463 001712 464 001720 465 001721 466 001723 467 001724 473 001725 478 001727 479 001732 482 001740 483 001742 484 001744 490 001766 492 001774 493 002001 495 002003 498 002005 499 002006 501 002020 502 002032 506 002035 508 002037 510 002050 512 002054 543 002055 549 002065 550 002070 552 002072 1002 002073 1005 002115 1007 002116 1008 002140 1010 002141 1013 002155 1015 002156 1016 002171 1018 002172 1021 002207 1023 002210 1024 002225 1026 002226 1029 002240 1030 002241 1032 002242 1034 002260 1036 002262 1038 002263 1041 002275 1042 002276 1044 002277 1046 002312 1048 002314 1050 002315 1053 002331 1055 002332 1056 002343 1058 002344 1061 002356 1063 002357 1064 002370 1066 002371 1069 002411 1071 002412 1072 002423 1074 002424 1077 002436 1079 002437 1081 002443 2973 002444 3310 002445 3313 002454 3314 002461 3316 002463 3318 002465 3320 002466 3323 002507 3324 002514 3326 002516 3327 002517 3328 002520 3330 002521 3333 002524 3334 002527 3336 002532 3337 002546 3340 002547 3344 002552 3346 002555 3347 002574 3350 002602 3351 002606 3353 002622 3355 002634 3360 002635 3362 002640 3364 002656 3367 002657 3370 002700 3371 002701 3373 002702 3374 002707 3376 002711 3377 002713 3379 002714 3383 002722 3384 002724 3385 002743 3389 002745 3390 002747 3391 002752 3394 002753 3399 002762 3400 002766 3401 002773 3402 003014 3405 003016 3407 003020 514 003021 519 003027 522 003036 525 003051 528 003075 529 003100 530 003102 531 003105 532 003142 535 003144 538 003157 555 003160 564 003162 565 003167 566 003173 567 003202 568 003205 570 003206 574 003207 580 003215 581 003250 583 003257 584 003271 587 003324 589 003326 590 003343 597 003344 616 003346 618 003352 621 003365 624 003366 625 003373 626 003374 628 003375 629 003377 633 003401 634 003407 635 003426 636 003434 639 003435 645 003443 648 003473 649 003475 650 003500 651 003503 654 003537 655 003543 659 003544 663 003552 665 003554 670 003561 671 003563 673 003606 676 003614 683 003636 684 003640 685 003645 686 003647 687 003657 688 003665 689 003670 690 003676 692 003702 696 003703 698 003712 700 003713 705 003714 721 003722 723 003731 725 003736 731 003743 732 003747 735 003754 736 003764 737 003773 741 003774 745 004000 746 004007 747 004013 748 004035 749 004044 750 004051 751 004102 753 004104 756 004106 757 004114 760 004116 763 004120 764 004137 765 004142 768 004143 771 004147 772 004153 773 004156 777 004157 779 004167 780 004177 782 004201 783 004211 786 004213 788 004221 790 004227 792 004234 794 004241 797 004250 799 004252 803 004263 808 004264 810 004271 811 004273 813 004274 815 004301 816 004303 818 004304 820 004311 821 004313 823 004314 825 004321 826 004323 828 004324 830 004331 831 004333 833 004334 835 004341 836 004343 838 004344 840 004351 841 004353 843 004354 845 004361 846 004363 848 004364 850 004371 851 004373 853 004374 855 004401 856 004403 858 004404 860 004411 861 004413 863 004414 865 004421 866 004423 868 004424 870 004431 871 004433 873 004434 875 004441 876 004443 878 004444 880 004451 881 004453 883 004454 885 004461 886 004463 888 004464 890 004471 891 004473 893 004474 895 004501 896 004503 898 004504 900 004511 901 004513 903 004514 905 004521 906 004523 908 004524 910 004531 911 004533 913 004534 915 004541 916 004543 918 004544 920 004551 921 004553 923 004554 925 004561 926 004563 928 004564 930 004571 931 004573 933 004574 935 004601 936 004603 938 004604 940 004611 941 004613 943 004614 945 004621 946 004623 948 004624 950 004631 951 004633 953 004634 955 004641 956 004643 958 004644 960 004651 961 004653 963 004654 965 004661 966 004663 968 004664 970 004671 971 004673 973 004674 975 004701 976 004703 978 004704 980 004711 981 004713 983 004714 985 004721 986 004723 988 004724 990 004731 991 004733 993 004734 995 004741 996 004743 1087 004744 1095 004745 1096 004752 1097 004755 1100 004756 1101 004764 1102 004767 1105 004770 1107 004773 1109 004775 1115 004776 1122 005004 1123 005006 1125 005040 1127 005101 1129 005103 1137 005111 1138 005113 1139 005120 1140 005122 1141 005137 1142 005140 1144 005142 1146 005143 1156 005151 1157 005153 1158 005157 1159 005161 1160 005201 1164 005202 1172 005210 1173 005212 1176 005221 1178 005222 1186 005230 1187 005232 1190 005241 1192 005242 1200 005250 1201 005252 1203 005256 1205 005257 1213 005265 1214 005267 1216 005274 1218 005275 1224 005303 1225 005305 1227 005322 1229 005323 1237 005331 1238 005333 1240 005356 1242 005357 1252 005365 1253 005367 1254 005374 1255 005400 1256 005403 1257 005406 1258 005407 1260 005411 1262 005412 1270 005420 1271 005422 1272 005426 1273 005430 1274 005432 1275 005435 1276 005444 1277 005466 1279 005473 1281 005474 1287 005502 1288 005504 1289 005505 1290 005510 1292 005511 1294 005512 1306 005520 1307 005522 1308 005542 1309 005552 1311 005563 1313 005565 1314 005573 1315 005625 1317 005630 1319 005631 1327 005637 1328 005641 1329 005675 1331 005703 1333 005704 1348 005712 1351 005714 1354 005720 1355 005745 1358 005750 1360 005757 1361 006001 1364 006011 1365 006024 1366 006037 1367 006071 1369 006075 1371 006104 1372 006105 1373 006115 1374 006137 1375 006147 1376 006162 1377 006165 1378 006203 1379 006235 1382 006241 1383 006250 1384 006251 1385 006256 1388 006260 1389 006266 1390 006270 1391 006303 1393 006306 1394 006332 1398 006335 1400 006350 1403 006351 1404 006356 1405 006372 1406 006402 1407 006407 1408 006424 1411 006425 1414 006446 1415 006453 1416 006470 1418 006473 1419 006524 1424 006526 1425 006541 1426 006564 1427 006565 1428 006572 1429 006607 1431 006612 1433 006670 1438 006671 1440 006723 1444 006725 1450 006733 1451 006750 1455 006751 1461 006757 1462 006775 1466 006776 1472 007004 1473 007022 1477 007023 1483 007031 1484 007047 1488 007050 1494 007056 1495 007074 1499 007075 1505 007103 1506 007121 1510 007122 1516 007130 1517 007146 1521 007147 1527 007155 1528 007173 1532 007174 1538 007202 1539 007220 1543 007221 1549 007227 1550 007245 1554 007246 1561 007254 1562 007256 1564 007270 1566 007272 1568 007312 1572 007313 1580 007321 1581 007323 1583 007334 1586 007336 1587 007356 1591 007357 1599 007365 1600 007367 1601 007373 1602 007414 1606 007415 1618 007423 1620 007430 1622 007452 1624 007462 1626 007475 1627 007501 1628 007505 1629 007510 1632 007511 1633 007524 1634 007531 1635 007554 1636 007560 1637 007561 1640 007604 1641 007632 1644 007633 1645 007651 1650 007652 1656 007660 1657 007662 1659 007671 1661 007672 1667 007700 1668 007702 1670 007711 1672 007712 1683 007720 1684 007722 1685 007726 1686 007735 1687 007743 1688 007745 1689 007762 1693 007763 1704 007771 1705 007773 1706 007777 1707 010006 1708 010014 1710 010031 1712 010032 1720 010040 1723 010042 1726 010062 1727 010064 1728 010101 1731 010104 1732 010111 1733 010146 1736 010150 1737 010152 1741 010153 1751 010161 1759 010202 1760 010206 1761 010210 1762 010215 1766 010216 1778 010224 1779 010225 1781 010226 1784 010234 1786 010236 1788 010240 1790 010242 1792 010253 1793 010260 1796 010261 1799 010265 1801 010275 1804 010311 1806 010314 1808 010333 1810 010350 1812 010351 1813 010360 1815 010370 1817 010376 1819 010411 1822 010412 1824 010414 1825 010424 1826 010434 1828 010444 1834 010445 1845 010453 1846 010455 1848 010457 1850 010470 1851 010475 1854 010476 1857 010502 1859 010504 1861 010513 1862 010525 1865 010530 1869 010543 1872 010562 1873 010571 1875 010601 1877 010607 1879 010621 1882 010622 1884 010624 1885 010634 1886 010644 1888 010654 1892 010655 1903 010663 1904 010665 1906 010700 1908 010703 1909 010713 1910 010723 1913 010737 1914 010742 1915 010753 1917 010766 1918 011004 1921 011012 1922 011021 1925 011027 1927 011033 1928 011042 1931 011050 1933 011054 1934 011057 1935 011071 1937 011103 1938 011105 1939 011147 1941 011157 1943 011160 1944 011166 1945 011204 1947 011212 1948 011255 1951 011264 1953 011273 1955 011274 1959 011275 1972 011303 1973 011310 1974 011317 1976 011324 1978 011333 1979 011341 1980 011342 1981 011351 1982 011356 1983 011360 1985 011361 1986 011370 1987 011375 1988 011404 1989 011411 1992 011413 1995 011414 1998 011415 1999 011444 2001 011461 2007 011462 2019 011470 2024 011477 2026 011512 2030 011515 2032 011533 2034 011540 2036 011545 2039 011547 2041 011550 2053 011556 2057 011564 2059 011574 2063 011577 2065 011621 2067 011627 2069 011634 2071 011636 2075 011637 2086 011653 2091 011655 2094 011666 2096 011672 2098 011712 2099 011721 2100 011722 2102 011723 2106 011724 2119 011735 2120 011736 2122 011737 2125 011750 2127 011752 2132 011753 2135 011767 2138 012006 2139 012016 2141 012025 2143 012027 2157 012030 2165 012041 2166 012060 2167 012065 2175 012066 2191 012074 2195 012100 2196 012104 2197 012110 2198 012111 2199 012113 2201 012114 2204 012151 2205 012155 2208 012156 2209 012175 2211 012202 2212 012215 2213 012224 2214 012243 2216 012246 2220 012270 2221 012273 2222 012302 2223 012326 2224 012333 2225 012335 2229 012341 2231 012343 2232 012350 2233 012351 2235 012361 2236 012362 2237 012366 2238 012367 2240 012371 2241 012425 2242 012433 2243 012435 2244 012437 2245 012441 2249 012442 2250 012445 2251 012446 2253 012456 2254 012457 2255 012463 2256 012464 2258 012466 2260 012523 2261 012531 2262 012533 2265 012537 2266 012574 2268 012604 2269 012611 2270 012613 2271 012616 2274 012617 2277 012626 2279 012632 2282 012634 2286 012641 2290 012647 2294 012652 2295 012667 2296 012677 2298 012700 2303 012701 2304 012713 2305 012737 2306 012744 2308 012746 2309 012773 2313 013003 2315 013012 2317 013014 2329 013015 2346 013033 2347 013035 2348 013041 2350 013042 2352 013044 2357 013047 2359 013053 2364 013110 2366 013116 2369 013121 2372 013135 2374 013137 2375 013160 2376 013161 2377 013164 2380 013165 2381 013211 2384 013215 2388 013230 2391 013274 2392 013276 2396 013300 2400 013301 2403 013307 2420 013311 2407 013325 2422 013344 2424 013403 2426 013407 2428 013416 2433 013426 2434 013441 2438 013455 2447 013463 2449 013465 2450 013471 2451 013501 2454 013512 2471 013526 2473 013540 2475 013545 2477 013547 2478 013554 2479 013562 2481 013570 2482 013572 2486 013601 2487 013606 2488 013610 2491 013620 2496 013651 2501 013702 2507 013742 2513 013777 2515 014000 2521 014002 2523 014005 2524 014006 2530 014020 2535 014026 2537 014031 2538 014034 2540 014054 2541 014064 2542 014071 2546 014072 2548 014074 2550 014121 2552 014130 2553 014137 2554 014160 2555 014170 2557 014171 2559 014201 2560 014211 2562 014212 2565 014231 2566 014241 2570 014246 2575 014247 2594 014260 2595 014263 2596 014264 2598 014271 2601 014275 2603 014324 2606 014332 2607 014334 2613 014336 2614 014342 2616 014360 2617 014362 2619 014363 2621 014365 2622 014367 2625 014372 2626 014374 2627 014375 2629 014400 2630 014407 2634 014432 2635 014436 2636 014442 2637 014445 2640 014446 2644 014453 2648 014464 2651 014500 2652 014505 2653 014511 2654 014515 2656 014516 2657 014527 2658 014535 2659 014555 2661 014563 2664 014564 2666 014600 2667 014602 2668 014604 2669 014624 2670 014642 2672 014650 2677 014651 2678 014655 2682 014663 2732 014664 2685 014665 2696 014667 2697 014671 2700 014674 2701 014703 2702 014713 2703 014717 2704 014725 2705 014730 2706 014733 2707 014737 2710 014740 2711 014743 2712 014745 2713 014750 2717 014751 2725 014753 2726 014754 2727 015002 2729 015010 2746 015011 2759 015017 2763 015022 2768 015026 2774 015045 2776 015050 2777 015060 2778 015063 2780 015065 2781 015070 2782 015073 2789 015075 2792 015114 2793 015121 2795 015126 2796 015136 2797 015137 2799 015140 2801 015165 2803 015211 2807 015213 2810 015221 2811 015226 2817 015227 2822 015230 2824 015234 2825 015242 2828 015256 2829 015262 2830 015265 2831 015270 2833 015272 2834 015274 2837 015275 2845 015277 2846 015303 2849 015311 2852 015313 2857 015315 2858 015320 2859 015343 2860 015346 2861 015347 2864 015352 2871 015354 2872 015361 2874 015366 2875 015373 2877 015376 2880 015377 2885 015400 2886 015406 2887 015431 2889 015443 2892 015453 2893 015455 2896 015461 2899 015473 2900 015475 2903 015501 2904 015523 2906 015527 2908 015530 2913 015545 2916 015550 2924 015552 2927 015564 2928 015570 2931 015605 2933 015610 2943 015612 2945 015614 2946 015621 2949 015624 2958 015626 2960 015640 2962 015642 2964 015643 2965 015655 2966 015724 2970 015727 2975 015730 2985 015736 2986 015740 2987 015775 2991 016005 2992 016011 2993 016013 2994 016015 2995 016017 2999 016021 3005 016032 3010 016041 3015 016052 3016 016106 3018 016116 3020 016117 3034 016133 3035 016155 3038 016164 3039 016170 3040 016172 3041 016174 3045 016175 3050 016203 3051 016214 3052 016223 3056 016224 3061 016232 3062 016243 3063 016252 3067 016253 3070 016254 3074 016261 3077 016273 3079 016275 3082 016304 3299 016310 3084 016311 3105 016317 3106 016323 3108 016325 3109 016327 3110 016331 3111 016333 3112 016336 3113 016340 3114 016342 3115 016345 3118 016350 3120 016364 3121 016370 3122 016375 3123 016405 3125 016406 3127 016424 3129 016425 3130 016432 3131 016435 3132 016436 3134 016441 3136 016450 3138 016453 3143 016454 3144 016455 3145 016465 3146 016507 3147 016516 3149 016520 3150 016521 3151 016533 3152 016555 3153 016564 3155 016566 3157 016621 3160 016622 3162 016636 3163 016642 3164 016647 3165 016657 3170 016660 3173 016703 3175 016767 3178 016771 3180 016772 3182 016777 3183 017002 3184 017003 3186 017006 3188 017015 3190 017026 3192 017031 3197 017033 3198 017037 3200 017041 3203 017056 3207 017072 3208 017073 3213 017100 3216 017105 3218 017106 3220 017107 3222 017114 3223 017133 3224 017143 3225 017150 3226 017151 3227 017153 3228 017172 3229 017202 3230 017207 3232 017210 3233 017212 3234 017231 3235 017241 3236 017246 3237 017273 3239 017303 3242 017310 3244 017313 3245 017324 3247 017334 3249 017335 3251 017342 3252 017361 3253 017371 3254 017376 3256 017377 3257 017401 3258 017420 3259 017430 3260 017435 3261 017465 3262 017475 3263 017502 3265 017503 3266 017505 3267 017524 3268 017534 3269 017541 3270 017571 3271 017601 3272 017606 3274 017607 3276 017614 3278 017617 3280 017620 3285 017622 3287 017641 3289 017662 3291 017672 3293 017704 3301 017712 3304 017713 3305 017717 3306 017720 3409 017723 3418 017731 3420 017741 ----------------------------------------------------------- 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