COMPILATION LISTING OF SEGMENT tty_io_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1155.08_Tue_mdt Options: optimize map 1 /****^ ************************************************************** 2* * * 3* * Copyright, (C) Massachusetts Institute of Technology, 1982 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* ************************************************************** */ 11 12 /* tty_io_ is the part of the tty_ io module that is used in 13* actual io operation. */ 14 15 16 /****^ HISTORY COMMENTS: 17* 1) change(81-03-17,BMargulies), approve(), audit(), install(): 18* Created. 19* Modified October 1981 by C. Hornig to time out on write_status calls. 20* Modified May 1982 by Robert Coren to accept (set get)_event_channel. 21* Modified 8 Sepctember 1982 by Richard Lamson to add timeout code. 22* Modified June 1983 by Robert Coren to make "get_channel_info" order 23* return device_used rather than device_id. 24* Modified April 1984 by Jon A. Rochlis to special case the "reconnection" 25* control order so tty_ reconnections don't hang with the new 26* reconnection strategy. 27* Modified 1984-10-29 BIM to remove constant non-local gotos. 28* Modified January 1985 by G. Palter for new treatment of dial_manager_ 29* attached channels. 30* Modified 1985-02-01, BIM: fixed timeout not to wait forever. 31* Modified 1985-02-19, BIM: added get_com_channel_info. 32* Modified: 26 February 1985 by G. Palter to fix the "set_event_channel" 33* control order to properly release any created-by-tty_ IPC channel. 34* 2) change(87-03-17,LJAdams), approve(87-04-03,MCR7646), 35* audit(87-05-05,Gilcrease), install(87-05-14,MR12.1-1030): 36* Changed ttd_version to ttd_version_3. 37* END HISTORY COMMENTS */ 38 39 40 /* format: style2 */ 41 42 tty_io_: 43 procedure; 44 return; 45 46 declare ( 47 arg_iocbp pointer, 48 arg_buf_ptr ptr, /* ptr to user buffer (input) */ 49 arg_buf_len fixed bin (21), /* length of user buffer (input) */ 50 (a_new_modes, a_old_modes) 51 char (*), /* arguments to modes operation */ 52 code fixed bin (35), /* the usual */ 53 chars_trans fixed bin (21), /* no. of characters transmitted (output) */ 54 info_ptr ptr, /* ptr to info (input) */ 55 no_of_records fixed bin (21), /* no. of lines to be skipped. tty_position (input) */ 56 order char (*), /* name of order. tty_control (input) */ 57 mode fixed bin /* position mode */ 58 ) parameter; 59 60 dcl timed_out bit (1) aligned; 61 dcl temp_code fixed bin (35); 62 dcl temp_state fixed bin; 63 64 dcl create_ips_mask_ entry (ptr, fixed bin, bit (36) aligned); 65 dcl get_com_channel_info_ entry (pointer, fixed binary (35)); 66 dcl hcs_$delete_channel entry (fixed bin (71), fixed bin (35)); 67 dcl ( 68 hcs_$set_ips_mask, 69 hcs_$reset_ips_mask 70 ) entry (bit (36) aligned, bit (36) aligned); 71 dcl hcs_$tty_abort entry (fixed bin, fixed bin, fixed bin, fixed bin (35)); 72 dcl hcs_$tty_event entry (fixed bin, fixed bin (71), fixed bin, fixed bin (35)); 73 dcl hcs_$tty_get_line entry (fixed bin, ptr, fixed bin (21), fixed bin (21), fixed bin (21), bit (1), 74 fixed bin, fixed bin (35)); 75 dcl hcs_$tty_order entry (fixed bin, char (*), ptr, fixed bin, fixed bin (35)); 76 dcl hcs_$tty_read entry (fixed bin, ptr, fixed bin (21), fixed bin (21), fixed bin (21), fixed bin, 77 fixed bin (35)); 78 dcl hcs_$tty_state entry (fixed bin, fixed bin, fixed bin (35)); 79 dcl hcs_$tty_write entry (fixed bin, ptr, fixed bin (21), fixed bin (21), fixed bin (21), fixed bin, 80 fixed bin (35)); 81 dcl ipc_$block entry (ptr, ptr, fixed bin (35)); 82 dcl ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)); 83 dcl ipc_$decl_ev_call_chn entry (fixed bin (71), entry, ptr, fixed bin, fixed bin (35)); 84 dcl ipc_$delete_ev_chn entry (fixed bin (71), fixed bin (35)); 85 dcl timer_manager_$alarm_wakeup 86 entry (fixed bin (71), bit (2), fixed bin (71)); 87 dcl timer_manager_$reset_alarm_wakeup 88 entry (fixed bin (71)); 89 dcl timer_manager_$sleep entry (fixed binary (71), bit (2)); 90 dcl tty_$tty_as_signal_handler 91 entry (pointer); 92 dcl ( 93 tty_io_call_control_, 94 tty_io_call_control_$not_open 95 ) entry (ptr, char (*), ptr, fixed bin (35)); 96 dcl ttt_info_$terminal_data 97 entry (char (*), fixed bin, fixed bin, ptr, fixed bin (35)); 98 dcl ttt_info_$initial_string 99 entry (char (*), char (512) varying, fixed bin (35)); 100 dcl ttt_info_$modes entry (char (*), char (*), fixed bin (35)); 101 102 dcl (addr, addrel, index, length, mod, null, reverse, rtrim, substr, charno, addcharno) 103 builtin; 104 105 dcl actual_iocbp ptr; /* copy of iocb.actual_ioc_ptr */ 106 dcl buffer_ptr ptr; /* ptr to the base of the segment pointed to by arg_buf_ptr */ 107 dcl control_not_open bit (1); 108 dcl event_channel fixed bin (71) based; 109 dcl event_wait_ptr pointer; 110 dcl (i, amt_trans) fixed bin (21); 111 dcl iox_op_in_progress fixed bin; 112 dcl initial_string char (512) varying;/* terminal initialization string */ 113 dcl ltype fixed bin; 114 dcl modes_ptr ptr; /* points to modes structure for hcs_$tty_order */ 115 dcl modes_need_restoration bit (1) aligned; 116 dcl nl_returned bit (1); 117 dcl num_to_read fixed bin (21); /* chars to request from hcs_$tty_read */ 118 dcl num_read fixed bin (21); /* number of chars returned from ring 0 */ 119 dcl offset fixed bin (21); /* offset from 0 for hcs_$tty_ calls */ 120 121 dcl Relative_Microseconds bit (2) static init ("10"b) options (constant); 122 dcl scratch_buffer_ptr pointer; 123 dcl scratch_buffer char (2000) aligned based (scratch_buffer_ptr); 124 dcl sis_version fixed bin int static options (constant) init (1); 125 /* version of send_initial_string_info structure */ 126 dcl sus_trm_names (3) char (32) int static options (constant) init ("sus_", "trm_", "alrm"); 127 dcl set_type_order bit (1) aligned; /* ON for set_type order, OFF for set_term_type */ 128 dcl state fixed bin; /* state returned by hcs_$tty_ calls */ 129 130 declare 1 timeout_event_wait aligned, 131 2 n_channels fixed binary, 132 2 padding fixed binary, 133 2 channel_id (2) fixed binary (71); 134 135 dcl total_amt_trans fixed bin (21); /* number of characters transferred */ 136 137 declare old_type fixed bin based (info_ptr); 138 139 dcl 1 ttd aligned like terminal_type_data; 140 /* info structure for set_terminal_data order (ring 0) */ 141 142 declare 1 send_initial_string_info 143 aligned like tty_send_initial_string_info based (info_ptr); 144 145 declare 1 get_channel_info aligned based (info_ptr) like tty_get_channel_info; 146 147 dcl 1 status_struc aligned based (info_ptr), 148 2 ev_chn fixed bin (71), 149 2 data_available bit (1) unaligned; 150 151 dcl 1 t_info aligned like terminal_info; 152 /* info structure for terminal_info order */ 153 154 dcl 1 event_message aligned like event_wait_info; 155 156 dcl based_state fixed bin based; 157 158 dcl 1 hangup_proc_data aligned based (info_ptr), 159 2 entry_var entry variable, 160 2 data_ptr ptr, 161 2 prior fixed bin; 162 163 dcl ( 164 error_table_$null_info_ptr, 165 error_table_$action_not_performed, 166 error_table_$timeout, 167 error_table_$out_of_sequence, 168 error_table_$smallarg, 169 error_table_$bad_arg, 170 error_table_$long_record, 171 error_table_$no_operation, 172 error_table_$not_open, 173 error_table_$unimplemented_version, 174 error_table_$undefined_order_request, 175 error_table_$no_initial_string, 176 error_table_$io_no_permission 177 ) fixed bin (35) external static; 178 179 dcl cleanup condition; 180 181 /* format: off */ 182 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 183 /* The new reconnection strategy is described here. At the entry to any of the i/o */ 184 /* entries (all but attach, open, close, detach) we increment */ 185 /* attach_data.operation_hlock. We then check attach_data.async_close and async_detach. */ 186 /* These indicate that we have had our switch removed out from under us. If the hlock is */ 187 /* one, meaning that we are the only operation suspended, and async_detach is on, then */ 188 /* we free the attach data. Otherwise we decrement the hlock. (half lock). Then, if the */ 189 /* iocb is in fact attached and opened, we call iox_ to do our operation on the new */ 190 /* switch, and return that result. There is a race window here, in that the async */ 191 /* operation could happen before we bump the counter. In that case the attach data would */ 192 /* be invalid and unpredictable. This seems unlikely, and is not handled in this */ 193 /* implementation. */ 194 /* */ 195 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 196 /* format: ^off */ 197 198 /* CONVENTIONS: 199* proper_io_return (code) does not return, and should be used 200* to return to caller of tty_io_. 201* 202* check_for_disconnect (code) checks for io_no_permission. If found 203* in goes and does reconnection and does not return. 204* If it does return, the code is the valid error code */ 205 206 control_not_open: 207 entry (arg_iocbp, order, info_ptr, code); 208 control_not_open = "1"b; 209 goto CONTROL_JOIN; 210 211 control: 212 entry (arg_iocbp, order, info_ptr, code); 213 control_not_open = ""b; 214 215 CONTROL_JOIN: 216 if (order = "get_chars_timeout") | (order = "get_line_timeout") | (order = "put_chars_timeout") 217 then do; /* need to initialize output value in info structure */ 218 if info_ptr = null () 219 then call proper_io_return (error_table_$null_info_ptr); 220 if order = "put_chars_timeout" 221 then info_ptr -> output_timeout_info.characters_written = 0; 222 else /*** if (order = "get_chars_timeout") | (order = "get_line_timeout") then */ 223 info_ptr -> input_timeout_info.characters_read = 0; 224 end; 225 226 call set_up_io (4); /* will abort the operation if there was an async hangup */ 227 on cleanup call clean_up; 228 229 if order = "reconnection" 230 then call proper_io_return (error_table_$unimplemented_version); 231 232 if order = "io_call" | order = "io_call_af" 233 then do; 234 if control_not_open 235 then call tty_io_call_control_$not_open (actual_iocbp, order, info_ptr, code); 236 else call tty_io_call_control_ (actual_iocbp, order, info_ptr, code); 237 call proper_io_return (code); 238 end; 239 240 if order = "set_event" | order = "set_event_channel" 241 then do; /* user wants to get wakeups */ 242 if control_not_open 243 then do; 244 attach_data.event_wait.channel_id = info_ptr -> event_channel; 245 attach_data.have_ev_channel = "1"b; 246 end; 247 else do; 248 249 /* see tty_ for explanation of this stuff about fast and slow channels */ 250 251 if attach_data.assigned_ev_channel 252 then do; 253 call hcs_$delete_channel (attach_data.event_wait.channel_id (1), code); 254 attach_data.assigned_ev_channel = "0"b; 255 end; 256 else if attach_data.created_ev_channel 257 then do; 258 call ipc_$delete_ev_chn (attach_data.event_wait.channel_id (1), code); 259 attach_data.created_ev_channel = "0"b; 260 end; 261 attach_data.event_wait.channel_id (1) = info_ptr -> event_channel; 262 call hcs_$tty_event (attach_data.tty_index, attach_data.event_wait.channel_id (1), state, 263 code); 264 if code ^= 0 265 then call check_for_disconnect (code); 266 call call_order ("start", null (), state, code); 267 if code ^= 0 268 then call check_for_disconnect (code); 269 end; 270 call proper_io_return (code); 271 end; 272 if order = "get_event" | order = "get_event_channel" 273 then do; 274 if ^attach_data.have_ev_channel 275 then call proper_io_return (error_table_$out_of_sequence); 276 info_ptr -> event_channel = attach_data.event_wait.channel_id (1); 277 call proper_io_return (code); 278 end; 279 280 281 if order = "state" 282 then do; 283 if info_ptr = null () 284 then call proper_io_return (error_table_$null_info_ptr); 285 call hcs_$tty_state (attach_data.tty_index, temp_state, temp_code); 286 info_ptr -> based_state = temp_state; 287 call proper_io_return (0); 288 end; 289 290 if order = "get_com_channel_info" 291 then do; 292 if info_ptr = null () 293 then call proper_io_return (error_table_$null_info_ptr); 294 info_ptr -> as_com_channel_info.channel_name = attach_data.device_used; 295 call get_com_channel_info_ (info_ptr, code); 296 call proper_io_return (code); 297 end; 298 299 if control_not_open /* no other orders for closed switches */ 300 then call proper_io_return (error_table_$not_open); 301 302 303 if order = "modes" 304 then do; /* turn this into a tty_modes call */ 305 call call_order ("modes", info_ptr, state, code); 306 call proper_io_return (code); 307 end; 308 309 if order = "resetread" 310 then call abort (1, code); /* abort dont return */ 311 if order = "resetwrite" 312 then call abort (2, code); 313 if order = "abort" 314 then call abort (3, code); 315 316 if order = "get_line_timeout" 317 then do; 318 timeout_info_ptr = info_ptr; 319 call timer_setup (input_timeout_info.timeout); 320 call get_line (input_timeout_info.buffer_pointer, input_timeout_info.buffer_length, 321 input_timeout_info.characters_read, input_timeout_info.timeout); 322 end; 323 324 if order = "get_chars_timeout" 325 then do; 326 timeout_info_ptr = info_ptr; 327 call timer_setup (input_timeout_info.timeout); 328 call get_chars (input_timeout_info.buffer_pointer, input_timeout_info.buffer_length, 329 input_timeout_info.characters_read, input_timeout_info.timeout); 330 /* And it never returns -- calls proper_io_return */ 331 end; 332 333 if order = "put_chars_timeout" 334 then do; 335 timeout_info_ptr = info_ptr; 336 call timer_setup (output_timeout_info.timeout); 337 338 call put_chars (output_timeout_info.buffer_pointer, output_timeout_info.buffer_length, 339 output_timeout_info.characters_written, output_timeout_info.timeout); 340 /* Never returns -- calls proper_io_return */ 341 end; 342 343 if order = "event_info" 344 then do; 345 info_ptr -> event_channel = attach_data.event_wait.channel_id (1); 346 call proper_io_return (0); 347 end; 348 349 if order = "set_term_type" 350 then do; 351 sttip = info_ptr; 352 if set_term_type_info.version ^= stti_version_1 353 then call proper_io_return (error_table_$unimplemented_version); 354 call get_terminal_info; 355 t_info.term_type = set_term_type_info.name; 356 if set_term_type_info.flags.ignore_line_type 357 then ltype = 0; 358 else ltype = t_info.line_type; 359 set_type_order = "0"b; 360 361 TYPE: 362 ttd.version = ttd_version_3; 363 call ttt_info_$terminal_data (t_info.term_type, ltype, t_info.baud_rate, addr (ttd), code); 364 if code ^= 0 365 then call proper_io_return (code); 366 367 call call_order ("set_terminal_data", addr (ttd), state, code); 368 if code ^= 0 369 then call proper_io_return (code); 370 371 if set_type_order 372 then call proper_io_return (code); 373 374 if set_term_type_info.flags.set_modes 375 then do; 376 call set_default_modes ("force,", code); 377 if code ^= 0 378 then call proper_io_return (code); 379 end; 380 381 if set_term_type_info.flags.send_initial_string 382 then do; 383 call send_default_initial_string (code); 384 if code ^= 0 385 then if code = error_table_$no_initial_string 386 then code = 0; 387 end; 388 389 call proper_io_return (code); 390 end; 391 392 if order = "set_default_modes" 393 then do; 394 call get_terminal_info; 395 call set_default_modes ("init,force,", code); 396 call proper_io_return (code); 397 end; 398 399 if order = "send_initial_string" 400 then do; 401 if info_ptr = null () 402 then do; 403 call get_terminal_info; 404 call send_default_initial_string (code); 405 end; 406 else do; 407 if send_initial_string_info.version ^= sis_version 408 then call proper_io_return (error_table_$unimplemented_version); 409 initial_string = send_initial_string_info.initial_string; 410 call send_initial_string (initial_string, code); 411 end; 412 call proper_io_return (code); 413 end; 414 415 if order = "set_type" | order = "set_terminal_type" 416 /* obsolete, map into set_term_type */ 417 then do; 418 if old_type < 1 | old_type > max_tty_type 419 then call proper_io_return (error_table_$undefined_order_request); 420 call get_terminal_info; 421 t_info.term_type = tty_dev_type (old_type); 422 ltype = 0; 423 set_type_order = "1"b; 424 go to TYPE; 425 end; 426 427 if order = "get_channel_info" 428 then do; 429 if get_channel_info.version ^= 1 430 then call proper_io_return (error_table_$unimplemented_version); 431 get_channel_info.devx = attach_data.tty_index; 432 get_channel_info.channel_name = attach_data.device_used; 433 call proper_io_return (0); 434 end; 435 436 if order = "hangup_proc" 437 then do; 438 if attach_data.dial_manager_event.channel_id (1) = 0 439 then call proper_io_return (error_table_$action_not_performed); 440 attach_data.user_hangup_proc.procedure = hangup_proc_data.entry_var; 441 attach_data.user_hangup_proc.data_ptr = hangup_proc_data.data_ptr; 442 attach_data.have_user_hangup_proc = "1"b; 443 call ipc_$decl_ev_call_chn (attach_data.dial_manager_event.channel_id (1), tty_$tty_as_signal_handler, 444 attach_data_ptr, hangup_proc_data.prior, code); 445 call proper_io_return (code); /* change the priority to the requested value */ 446 end; 447 448 do; 449 call call_order (order, info_ptr, state, code); 450 /* see if hardcore knows it */ 451 if code ^= 0 452 then call proper_io_return (code); 453 454 if order = "read_status" /* our part of this bargain */ 455 then status_struc.ev_chn = attach_data.event_wait.channel_id (1); 456 if order = "write_status" 457 then do; 458 status_struc.ev_chn = attach_data.event_wait.channel_id (1); 459 if status_struc.data_available 460 then call timer_manager_$alarm_wakeup (1, "11"b, status_struc.ev_chn); 461 end; 462 end; 463 call proper_io_return (code); /* assume hardcore sets code for unknown order */ 464 465 /* The user makes a modes call with two strings: one for new modes and one for old modes. 466* The hardcore overwrites the new modes with the old modes, so the user's mode string must be copied 467* into a scratch buffer for the hardcore call. 468**/ 469 470 modes: 471 entry (arg_iocbp, a_new_modes, a_old_modes, code); 472 473 call set_up_io (6); 474 on cleanup call clean_up; 475 476 call set_modes ("", a_new_modes, a_old_modes, code); 477 call proper_io_return (code); 478 479 /* The only request that makes sense for terminals is forward skip of records. 480* mode = 0 skip records 481* no_of_records >= 0 forward skip 482**/ 483 484 tty_io_$position: 485 entry (arg_iocbp, mode, no_of_records, code); 486 487 call set_up_io (5); 488 if mode ^= 0 | no_of_records < 0 489 then call proper_io_return (error_table_$no_operation); 490 491 on cleanup call clean_up; 492 493 if no_of_records > 0 494 then do; 495 allocate scratch_buffer; /* freed by proper_io_return_ */ 496 event_wait_ptr = addr (attach_data.event_wait); 497 i = 0; 498 499 do while (i < no_of_records); 500 501 call read (addr (scratch_buffer), length (scratch_buffer), amt_trans, 0, "1"b, code); 502 if code ^= 0 503 then call proper_io_return (code); 504 if nl_returned 505 then i = i + 1; 506 end; 507 end; 508 call proper_io_return (code); 509 510 /* This procedure sets the pointer to the actual iocb ptr and sets the attach_data_ptr. 511**/ 512 513 set_up: 514 procedure; 515 516 code = 0; 517 actual_iocbp = arg_iocbp -> iocb.actual_iocb_ptr; 518 attach_data_ptr = actual_iocbp -> iocb.attach_data_ptr; 519 timeout_info_ptr = null (); 520 modes_need_restoration = "0"b; 521 scratch_buffer_ptr = null (); 522 return; 523 524 end set_up; 525 526 527 set_up_io: 528 procedure (which_op); 529 530 dcl which_op fixed bin; 531 532 call set_up; 533 attach_data.operation_hlock = attach_data.operation_hlock + 1; 534 iox_op_in_progress = which_op; /* allow us to retry this op -- see IOX* labels */ 535 call check_async; 536 return; 537 end set_up_io; 538 539 get_terminal_info: 540 proc; /* performs ring 0 terminal_info order */ 541 542 t_info.version = terminal_info_version; 543 544 call call_order ("terminal_info", addr (t_info), state, code); 545 if code ^= 0 546 then call proper_io_return (code); 547 end get_terminal_info; 548 549 /* Internal procedure to set default or user-specified modes */ 550 551 set_default_modes: 552 proc (prefix, code); /* assumes terminal type given by t_info.term_type */ 553 554 dcl prefix char (*); 555 dcl code fixed bin (35); 556 557 call ttt_info_$modes (t_info.term_type, attach_data.temp_mode_string, code); 558 /* get default modes */ 559 if code ^= 0 | attach_data.temp_mode_string = "" 560 then return; 561 562 call set_modes (prefix, attach_data.temp_mode_string, "", code); 563 end set_default_modes; 564 565 set_modes: 566 procedure (new_mode_prefix, new_modes, old_modes, code); 567 568 dcl (new_mode_prefix, new_modes, old_modes) 569 char (*); 570 dcl code fixed bin (35); 571 dcl commax fixed bin (21); 572 dcl prefix_in_use bit (1) aligned; /* the prefix arg avoids concatenation stack extensions in our callers */ 573 dcl returned_length fixed bin (21); 574 575 if new_mode_prefix ^= "" 576 then prefix_in_use = "1"b; 577 else prefix_in_use = "0"b; 578 579 modes_ptr = addr (attach_data.mode_string_info); 580 581 if prefix_in_use 582 then attach_data.mode_string_info.mode_string = new_mode_prefix || new_modes; 583 else attach_data.mode_string_info.mode_string = new_modes; 584 585 call call_order ("modes", modes_ptr, state, code); 586 587 if code ^= 0 & code ^= error_table_$smallarg 588 then do; 589 old_modes = attach_data.mode_string_info.mode_string; 590 /* the mode(s) in error are in here */ 591 return; 592 end; 593 594 if length (old_modes) = 0 595 then do; 596 code = 0; /* censor smallarg on "" old_modes */ 597 return; 598 end; 599 600 returned_length = length (rtrim (attach_data.mode_string_info.mode_string)); 601 if returned_length = 0 /* nothing in either direction */ 602 then do; 603 code = 0; 604 old_modes = ""; 605 return; 606 end; 607 608 /* from this point on we can have a smallarg */ 609 610 code = 0; /* but we do not admit it. */ 611 612 /**** Note -- attach_data.mode_string is maintained to be long enough 613* for whatever the hardcore could possibly say, unless someone 614* invents a funny mpx that gave wildly different mode string lengths. 615* So we assume that attach_data.mode_string is not truncated, 616* and don't bother checking for the "." 617* 618* So long as the user gave us as much space, we have faith that 619* no manipulations of the string are needed. */ 620 621 if returned_length <= length (old_modes) 622 then do; 623 old_modes = attach_data.mode_string_info.mode_string; 624 return; 625 end; 626 627 /**** Here, we want to truncate to the last full mode */ 628 629 commax = index (reverse (substr (attach_data.mode_string_info.mode_string, 1, length (old_modes))), ","); 630 if commax = 0 /** hmmm, no room for an modes at all */ 631 then old_modes = "."; 632 else do; 633 substr (old_modes, 1, length (old_modes) - commax) = 634 substr (attach_data.mode_string_info.mode_string, 1, length (old_modes) - commax); 635 substr (old_modes, length (old_modes) - commax + 1) = "."; 636 /* fill with spaces */ 637 end; 638 return; 639 end set_modes; 640 641 /* Internal procedure to set default and user-specified initial_string */ 642 643 send_default_initial_string: 644 proc (code); /* assumes terminal type given by t_info.term_type */ 645 646 dcl code fixed bin (35); 647 648 call ttt_info_$initial_string (t_info.term_type, initial_string, code); 649 if code ^= 0 650 then return; 651 if length (initial_string) = 0 652 then do; 653 code = error_table_$no_initial_string; 654 return; 655 end; 656 657 go to sis_common; 658 659 send_initial_string: 660 entry (a_initial_string, code); 661 662 dcl a_initial_string character (*) varying; 663 664 initial_string = a_initial_string; 665 666 sis_common: 667 attach_data.temp_mode_string = ""; 668 modes_need_restoration = "1"b; 669 670 call set_modes ("", "rawo", attach_data.temp_mode_string, code); 671 if code ^= 0 672 then return; /* Recurse, recurse */ 673 call tty_io_$put_chars (arg_iocbp, addrel (addr (initial_string), 1), length (initial_string), code); 674 /* skip varying string. YCCH */ 675 /* not to mention no_block implications... */ 676 /* this should be coded as call to write_chars, all things considered */ 677 678 call set_modes ("", attach_data.temp_mode_string, "", (0)); 679 /* best work */ 680 modes_need_restoration = "0"b; 681 return; 682 end send_default_initial_string; 683 684 685 /* this procedure is called after any hcs_$tty_ entry. 686* if we are not a login_channel, then we return. 687* if we are, then 688* in the io no permission case, it waits 10 seconds for sus_ to happen. 689* if the async bits are set, then the reconnection came off. if not, we 690* we wait again. using -login_channel if you do not mean it is not recommended, 691* as the async bits would never get set. sus_signal_handler_ will take care of anyone 692* who is attached with -login_channel. */ 693 694 check_for_disconnect: 695 procedure (code); 696 697 dcl temp_state fixed bin; 698 dcl temp_code fixed bin (35); 699 dcl mask_to_set bit (36) aligned; 700 dcl mask_to_reset bit (36) aligned; 701 dcl code fixed bin (35); 702 703 if ^attach_data.login_channel 704 then return; /* not our problem */ 705 if attach_data.async_detach 706 then go to fake_operation_and_return; 707 708 call hcs_$tty_state (attach_data.tty_index, temp_state, temp_code); 709 /* is it ours? */ 710 if temp_code = 0 711 then return; /* we still own channel, must be some other error */ 712 713 /* we dont own channel, but no bits. must be we havent got sus_'ed */ 714 call create_ips_mask_ (addr (sus_trm_names), 3, mask_to_set); 715 /* better include alrm, for timing */ 716 mask_to_set = ^mask_to_set; /* form enable mask */ 717 718 /* sit in a loop and wait for the answering service to goose us. 719* the answering service should suspend us, and then afterwards 720* take us out. 721**/ 722 call hcs_$set_ips_mask (mask_to_set, mask_to_reset); 723 /* mask to AS signals only */ 724 725 do while (^attach_data.async_detach); 726 call timer_manager_$sleep (1, "11"b); 727 end; 728 729 call hcs_$reset_ips_mask (mask_to_reset, (36)"0"b); 730 731 goto fake_operation_and_return; 732 733 check_async: 734 entry; 735 736 if attach_data.async_detach 737 then go to fake_operation_and_return; 738 else if attach_data.async_hangup 739 then call proper_io_return (error_table_$io_no_permission); 740 else return; 741 742 end check_for_disconnect; 743 744 745 746 fake_operation_and_return: /* label since we really return */ 747 revert cleanup; /* do not try to run unlock_hlock on freed attach data */ 748 if attach_data.operation_hlock = 1 749 then free attach_data; /* and we are the last */ 750 else call unlock_hlock; 751 752 goto IOX_OPERATION (iox_op_in_progress); 753 754 IOX_OPERATION (1): /* get_chars */ 755 call iox_$get_chars (actual_iocbp, arg_buf_ptr, arg_buf_len, chars_trans, code); 756 return; 757 758 IOX_OPERATION (2): /* get_line */ 759 call iox_$get_line (actual_iocbp, arg_buf_ptr, arg_buf_len, chars_trans, code); 760 return; 761 762 IOX_OPERATION (3): /* put_chars */ 763 call iox_$put_chars (actual_iocbp, arg_buf_ptr, arg_buf_len, code); 764 return; 765 766 IOX_OPERATION (4): /* control */ 767 call iox_$control (actual_iocbp, order, info_ptr, code); 768 return; 769 770 IOX_OPERATION (5): /* position */ 771 call iox_$position (actual_iocbp, mode, no_of_records, code); 772 return; 773 774 IOX_OPERATION (6): /* modes */ 775 call iox_$modes (actual_iocbp, a_old_modes, a_new_modes, code); 776 return; 777 778 unlock_hlock: 779 procedure; 780 attach_data.operation_hlock = attach_data.operation_hlock - 1; 781 end unlock_hlock; 782 783 proper_io_return: 784 procedure (r_code); 785 declare r_code fixed bin (35); 786 787 code = r_code; 788 go to proper_io_return_label_; 789 end proper_io_return; 790 791 proper_io_return_label_: 792 if timeout_info_ptr ^= null () 793 then call timer_cleanup; 794 call modes_cleanup; 795 if scratch_buffer_ptr ^= null () 796 then free scratch_buffer; 797 call unlock_hlock; 798 return; 799 800 tty_io_$get_chars: 801 entry (arg_iocbp, arg_buf_ptr, arg_buf_len, chars_trans, code); 802 803 chars_trans = 0; /* initialize output value in case set_up_io aborts */ 804 call set_up_io (1); /* manage half-lock and get actual_iocb_ptr, attach_data */ 805 on cleanup call clean_up; /* never freed */ 806 807 call get_chars (arg_buf_ptr, arg_buf_len, chars_trans, -1); 808 /* It never returns -- calls proper_io_return */ 809 810 get_chars: 811 procedure (arg_buf_ptr, arg_buf_len, chars_trans, arg_timeout); 812 813 declare ( 814 arg_buf_ptr pointer, 815 (arg_buf_len, chars_trans) 816 fixed binary (21), 817 arg_timeout fixed binary (71) 818 ) parameter; 819 820 if arg_timeout < 0 821 then event_wait_ptr = addr (attach_data.event_wait); 822 else if arg_timeout = 0 823 then event_wait_ptr = null (); 824 825 chars_trans = 0; 826 if arg_buf_len < 0 827 then call proper_io_return (error_table_$bad_arg); 828 buffer_ptr = arg_buf_ptr; 829 offset = mod (charno (buffer_ptr), 4); 830 buffer_ptr = addcharno (buffer_ptr, -offset); 831 call read (buffer_ptr, arg_buf_len, chars_trans, offset, "0"b, code); 832 call proper_io_return (code); 833 834 end get_chars; 835 836 tty_io_$get_line: 837 entry (arg_iocbp, arg_buf_ptr, arg_buf_len, chars_trans, code); 838 839 chars_trans = 0; /* initialize output value in case set_up_io aborts */ 840 call set_up_io (2); 841 on cleanup call clean_up; 842 843 call get_line (arg_buf_ptr, arg_buf_len, chars_trans, -1); 844 845 get_line: 846 procedure (arg_buf_ptr, arg_buf_len, chars_trans, arg_timeout); 847 848 declare ( 849 arg_buf_ptr pointer, 850 (arg_buf_len, chars_trans) 851 fixed binary (21), 852 arg_timeout fixed binary (71) 853 ) parameter; 854 855 if arg_timeout < 0 856 then event_wait_ptr = addr (attach_data.event_wait); 857 else if arg_timeout = 0 858 then event_wait_ptr = null (); /* no blocking */ 859 860 chars_trans = 0; 861 if arg_buf_len < 0 862 then call proper_io_return (error_table_$bad_arg); 863 if arg_buf_len = 0 864 then call proper_io_return (0); 865 866 buffer_ptr = arg_buf_ptr; 867 offset = mod (charno (buffer_ptr), 4); 868 buffer_ptr = addcharno (buffer_ptr, -offset); 869 num_to_read = arg_buf_len; 870 871 do while (num_to_read > 0); /* until we get a newline or run out of space */ 872 call read (buffer_ptr, num_to_read, num_read, offset, "1"b, code); 873 chars_trans = chars_trans + num_read; /* BEFORE we check the code, so that long_record and timeout and such correctly return the number we read */ 874 875 if code ^= 0 876 then call proper_io_return (code); 877 878 if nl_returned 879 then call proper_io_return (0); /* ring 0 will say whether it found newline */ 880 881 if attach_data.no_block | arg_timeout = 0 882 then call proper_io_return (0); /* nothing counts as a line for get line */ 883 offset = offset + num_read; /* no newline, read some more */ 884 num_to_read = num_to_read - num_read; 885 end; 886 887 call proper_io_return (error_table_$long_record); /* never got a newline */ 888 end get_line; 889 890 /* This entry is called to output characters. The hardcore dim may output less than was requested 891* and may have to be called more than once. These conditions may occur if the hardcore did not 892* complete the request: 893* 894* . code = 0 The hardcore was given more characters than it could process; the process goes 895* . blocked and makes another output request after the wakeup. 896* 897* . code ^= 0 The process has lost the attachment to the terminal. The error code no_io_permission is 898* . returned. 899* 900* . state ^= TTY_STATE_DIALED_UP this only will come back in the Real Owner's process, currently 901* the Initializer. 902* The terminal has hungup. The error code no_io_permission is returned. 903**/ 904 905 tty_io_$put_chars: 906 entry (arg_iocbp, arg_buf_ptr, arg_buf_len, code); 907 908 call set_up_io (3); 909 on cleanup call clean_up; 910 911 call put_chars (arg_buf_ptr, arg_buf_len, (0), -1); 912 /* It never returns -- calls proper_io_return */ 913 put_chars: 914 procedure (arg_buf_ptr, arg_buf_len, arg_chars_written, arg_timeout); 915 916 declare ( 917 arg_buf_ptr pointer, 918 arg_buf_len fixed binary (21), 919 arg_chars_written fixed binary (21), 920 arg_timeout fixed binary (71) 921 ) parameter; 922 923 if arg_timeout < 0 924 then event_wait_ptr = addr (attach_data.event_wait); 925 else if arg_timeout = 0 926 then event_wait_ptr = null (); 927 /*** else set by timer_setup */ 928 929 if arg_buf_len < 0 930 then call proper_io_return (error_table_$bad_arg); 931 932 if arg_buf_len = 0 933 then call proper_io_return (0); 934 935 buffer_ptr = arg_buf_ptr; 936 offset = mod (charno (buffer_ptr), 4); 937 buffer_ptr = addcharno (buffer_ptr, -offset); 938 total_amt_trans = 0; 939 940 timed_out = "0"b; /* we retry the operation after the time out interval even without a detectable wakeup */ 941 do while ("1"b); 942 amt_trans = 0; 943 call write_chars (buffer_ptr, offset, arg_buf_len - total_amt_trans, amt_trans, state, code); 944 if code ^= 0 945 then do; 946 arg_chars_written = total_amt_trans; 947 call proper_io_return (code); 948 end; 949 total_amt_trans = total_amt_trans + amt_trans; 950 if total_amt_trans >= arg_buf_len 951 then do; 952 arg_chars_written = total_amt_trans; 953 call proper_io_return (0); /* done! */ 954 end; 955 956 if arg_timeout >= 0 /* timeout requires output args */ 957 then do; 958 arg_chars_written = total_amt_trans; 959 if arg_timeout = 0 | timed_out /* timed_out --> that we timed out already but are just giving one more push */ 960 then call proper_io_return (error_table_$timeout); 961 end; 962 else if attach_data.no_block /* no_block + timeout = block on timer only */ 963 then do; 964 if arg_buf_len > total_amt_trans 965 then code = total_amt_trans - arg_buf_len; 966 /* - (number not transmitted) */ 967 arg_chars_written = total_amt_trans; 968 call proper_io_return (code); 969 end; 970 offset = offset + amt_trans; 971 call ipc_$block (event_wait_ptr, addr (event_message), code); 972 if code ^= 0 973 then call proper_io_return (code); /* ipc failure? this is bad luck, perhaps should signal */ 974 call check_async (); /* check for having lost the channel while blocked */ 975 if event_message.channel_id ^= attach_data.event_wait.channel_id (1) 976 then timed_out = "1"b; /* attach_data.event_wait.channel_id (1) is ALWAYS the tty itself, and the only other possibility is the timer event */ 977 /* setting this flag causes it to try to write one more time before returning. */ 978 979 end; 980 end put_chars; 981 982 write_chars: 983 procedure (bufferp, buffero, n_to_write, n_wrote, statex, code); 984 985 declare ( 986 bufferp ptr, 987 (buffero, n_to_write, n_wrote) 988 fixed bin (21), 989 statex fixed bin, 990 code fixed bin (35) 991 ) parameter; 992 993 call hcs_$tty_write (attach_data.tty_index, bufferp, buffero, n_to_write, n_wrote, statex, code); 994 if code ^= 0 995 then call check_for_disconnect (code); 996 return; 997 end write_chars; 998 999 /* This procedure reads one line of data or "amt_to_read" characters whichever is smaller. */ 1000 1001 read: 1002 proc (buffer_ptr, amt_to_read, amt_read, offset, get_line_called, code); 1003 1004 dcl buffer_ptr ptr; 1005 dcl amt_to_read fixed bin (21); 1006 dcl amt_read fixed bin (21); 1007 dcl offset fixed bin (21); 1008 dcl get_line_called bit (1); 1009 dcl code fixed bin (35); 1010 1011 amt_read = 0; 1012 1013 timed_out = "0"b; 1014 do while ("1"b); 1015 if get_line_called 1016 then call hcs_$tty_get_line (attach_data.tty_index, buffer_ptr, offset, amt_to_read, amt_read, nl_returned, 1017 state, code); 1018 else call hcs_$tty_read (attach_data.tty_index, buffer_ptr, offset, amt_to_read, amt_read, state, code); 1019 1020 if code ^= 0 1021 then do; 1022 call check_for_disconnect (code); /* will NOT return if io_no_permission */ 1023 return; 1024 end; 1025 1026 if amt_read > 0 1027 then return; 1028 if event_wait_ptr = null () /* 0 timeout */ | timed_out 1029 /* we hung out a read, it timed out, we tried one last time, got nothing, and so away we go */ 1030 then call proper_io_return (error_table_$timeout); 1031 1032 if attach_data.no_block 1033 then return; /* the n-chars-read will be zero, no problem, no code needed */ 1034 call ipc_$block (event_wait_ptr, addr (event_message), code); 1035 if code ^= 0 1036 then return; 1037 call check_async (); /* check for having lost the channel while blocked */ 1038 if event_message.channel_id ^= attach_data.event_wait.channel_id (1) 1039 then timed_out = "1"b; 1040 end; 1041 end read; 1042 1043 1044 timer_setup: 1045 procedure (arg_timeout); 1046 1047 declare arg_timeout fixed bin (71); 1048 declare channel fixed bin (71); 1049 1050 if arg_timeout = 0 1051 then return; /* timeout of zero special */ 1052 call ipc_$create_ev_chn (channel, code); 1053 if code ^= 0 1054 then call proper_io_return (code); 1055 if attach_data.no_block 1056 then do; 1057 timeout_event_wait.channel_id (1) = channel; 1058 timeout_event_wait.n_channels = 1; 1059 end; 1060 else do; 1061 timeout_event_wait.channel_id (1) = attach_data.event_wait.channel_id (1); 1062 timeout_event_wait.channel_id (2) = channel; 1063 timeout_event_wait.n_channels = 2; 1064 end; 1065 call timer_manager_$alarm_wakeup (arg_timeout, Relative_Microseconds, timeout_event_wait.channel_id (2)); 1066 event_wait_ptr = addr (timeout_event_wait); 1067 return; 1068 end timer_setup; 1069 1070 modes_cleanup: 1071 procedure; 1072 1073 /**** Restore modes by hand to avoid forcing a bunch of useful 1074* procedures to be non-quick. */ 1075 1076 if ^modes_need_restoration 1077 then return; 1078 attach_data.mode_string_info.mode_string = attach_data.temp_mode_string; 1079 call hcs_$tty_order (attach_data.tty_index, "modes", addr (attach_data.mode_string_info), state, code); 1080 1081 return; 1082 end modes_cleanup; 1083 1084 timer_cleanup: 1085 procedure; 1086 1087 if timeout_info_ptr = null () 1088 then return; 1089 call timer_manager_$reset_alarm_wakeup (timeout_event_wait.channel_id (2)); 1090 call ipc_$delete_ev_chn (timeout_event_wait.channel_id (2), (0)); 1091 return; 1092 1093 end timer_cleanup; 1094 1095 abort: 1096 procedure (abort_type, code); 1097 1098 dcl abort_type fixed bin; 1099 dcl code fixed bin (35); 1100 1101 call hcs_$tty_abort (attach_data.tty_index, (abort_type), state, code); 1102 if code ^= 0 1103 then call check_for_disconnect (code); 1104 call proper_io_return (code); 1105 end abort; 1106 1107 call_order: 1108 procedure (order, info_ptr, state, code); 1109 1110 dcl order char (*); 1111 dcl info_ptr ptr; 1112 dcl state fixed bin; 1113 dcl code fixed bin (35); 1114 1115 call hcs_$tty_order (attach_data.tty_index, order, info_ptr, state, code); 1116 if code ^= 0 1117 then call check_for_disconnect (code); 1118 end call_order; 1119 1120 clean_up: 1121 procedure; 1122 1123 call timer_cleanup; 1124 call modes_cleanup; 1125 if scratch_buffer_ptr ^= null () 1126 then free scratch_buffer; 1127 call unlock_hlock; 1128 end clean_up; 1129 1130 1131 1 1 /* Begin include file as_com_channel_info.incl.pl1 */ 1 2 1 3 /* Created 1985-02-19 by BIM */ 1 4 /* Recreated 1985-02-22 by E. Swenson since the include file was lost. */ 1 5 1 6 /* format: style4 */ 1 7 1 8 dcl as_com_channel_info_ptr pointer; 1 9 dcl 1 as_com_channel_info aligned 1 10 based (as_com_channel_info_ptr), 1 11 2 version char (8), 1 12 2 channel_name char (32), 1 13 2 flags aligned, 1 14 3 access_control unaligned, 1 15 4 login bit (1), 1 16 4 dial_slave bit (1), 1 17 4 priv_attach bit (1), 1 18 4 dial_server bit (1), 1 19 4 dial_out bit (1), 1 20 3 attached_to_caller bit (1) unaligned, 1 21 3 user_authenticated bit (1) unaligned, 1 22 3 dialed_to_caller bit (1) unaligned, 1 23 3 pad bit (28) unaligned, 1 24 2 service_type fixed bin, 1 25 2 current_service_type fixed bin, 1 26 2 access_class (2) bit (72) aligned, 1 27 2 current_access_class bit (72) aligned, 1 28 2 auth_user_name char (32) unaligned; 1 29 1 30 declare AS_COM_CHANNEL_INFO_VERSION_1 char (8) aligned init ("ascci001") int static options (constant); 1 31 1 32 /* End include file as_com_channel_info.incl.pl1 */ 1132 2 1 /* BEGIN INCLUDE FILE event_wait_info.incl.pl1 */ 2 2 2 3 /* T. Casey, May 1978 */ 2 4 2 5 dcl event_wait_info_ptr ptr; 2 6 2 7 dcl 1 event_wait_info aligned based (event_wait_info_ptr), /* argument structure filled in on return from ipc_$block */ 2 8 2 channel_id fixed bin (71), /* event channel on which wakeup occurred */ 2 9 2 message fixed bin (71), /* 72 bits of information passed by sender of wakeup */ 2 10 2 sender bit (36), /* process id of sender */ 2 11 2 origin, 2 12 3 dev_signal bit (18) unaligned, /* "1"b if device signal */ 2 13 3 ring fixed bin (17) unaligned, /* ring from which sent */ 2 14 2 channel_index fixed bin; /* index of this channel in the event wait list */ 2 15 2 16 /* END INCLUDE FILE event_wait_info.incl.pl1 */ 1133 3 1 /* BEGIN INCLUDE FILE ..... iocb.incl.pl1 ..... 13 Feb 1975, M. Asherman */ 3 2 /* Modified 11/29/82 by S. Krupp to add new entries and to change 3 3* version number to IOX2. */ 3 4 /* format: style2 */ 3 5 3 6 dcl 1 iocb aligned based, /* I/O control block. */ 3 7 2 version character (4) aligned, /* IOX2 */ 3 8 2 name char (32), /* I/O name of this block. */ 3 9 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 3 10 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 3 11 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 3 12 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 3 13 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 3 14 2 reserved bit (72), /* Reserved for future use. */ 3 15 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 3 16 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 3 17 /* open(p,mode,not_used,s) */ 3 18 2 close entry (ptr, fixed (35)),/* close(p,s) */ 3 19 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 3 20 /* get_line(p,bufptr,buflen,actlen,s) */ 3 21 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 3 22 /* get_chars(p,bufptr,buflen,actlen,s) */ 3 23 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 3 24 /* put_chars(p,bufptr,buflen,s) */ 3 25 2 modes entry (ptr, char (*), char (*), fixed (35)), 3 26 /* modes(p,newmode,oldmode,s) */ 3 27 2 position entry (ptr, fixed, fixed (21), fixed (35)), 3 28 /* position(p,u1,u2,s) */ 3 29 2 control entry (ptr, char (*), ptr, fixed (35)), 3 30 /* control(p,order,infptr,s) */ 3 31 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 3 32 /* read_record(p,bufptr,buflen,actlen,s) */ 3 33 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 3 34 /* write_record(p,bufptr,buflen,s) */ 3 35 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 3 36 /* rewrite_record(p,bufptr,buflen,s) */ 3 37 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 3 38 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 3 39 /* seek_key(p,key,len,s) */ 3 40 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 3 41 /* read_key(p,key,len,s) */ 3 42 2 read_length entry (ptr, fixed (21), fixed (35)), 3 43 /* read_length(p,len,s) */ 3 44 2 open_file entry (ptr, fixed bin, char (*), bit (1) aligned, fixed bin (35)), 3 45 /* open_file(p,mode,desc,not_used,s) */ 3 46 2 close_file entry (ptr, char (*), fixed bin (35)), 3 47 /* close_file(p,desc,s) */ 3 48 2 detach entry (ptr, char (*), fixed bin (35)); 3 49 /* detach(p,desc,s) */ 3 50 3 51 declare iox_$iocb_version_sentinel 3 52 character (4) aligned external static; 3 53 3 54 /* END INCLUDE FILE ..... iocb.incl.pl1 ..... */ 1134 4 1 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 4 2 4 3 /* Written 05/04/78 by C. D. Tavares */ 4 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 4 5 /* Modified 5/83 by S. Krupp to add declarations for: iox_$open_file, 4 6* iox_$close_file, iox_$detach and iox_$attach_loud entries. */ 4 7 4 8 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 4 9 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 4 10 iox_$close entry (pointer, fixed bin (35)), 4 11 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 4 12 iox_$delete_record entry (pointer, fixed bin (35)), 4 13 iox_$destroy_iocb entry (pointer, fixed bin (35)), 4 14 iox_$detach_iocb entry (pointer, fixed bin (35)), 4 15 iox_$err_not_attached entry options (variable), 4 16 iox_$err_not_closed entry options (variable), 4 17 iox_$err_no_operation entry options (variable), 4 18 iox_$err_not_open entry options (variable), 4 19 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 4 20 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 4 21 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 4 22 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 4 23 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 4 24 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 4 25 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 4 26 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 4 27 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 4 28 iox_$propagate entry (pointer), 4 29 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 4 30 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 4 31 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 4 32 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 4 33 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 4 34 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 4 35 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 4 36 iox_$open_file entry(ptr, fixed bin, char(*), bit(1) aligned, fixed bin(35)), 4 37 iox_$close_file entry(ptr, char(*), fixed bin(35)), 4 38 iox_$detach entry(ptr, char(*), fixed bin(35)), 4 39 iox_$attach_loud entry(ptr, char(*), ptr, fixed bin(35)); 4 40 4 41 dcl (iox_$user_output, 4 42 iox_$user_input, 4 43 iox_$user_io, 4 44 iox_$error_output) external static pointer; 4 45 4 46 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 1135 5 1 /* BEGIN: tty_attach_data_.incl.pl1 * * * * * */ 5 2 5 3 5 4 /****^ HISTORY COMMENTS: 5 5* 1) change(81-01-01,Margulies), approve(), audit(), install(): 5 6* Created from internal declarations. 5 7* 2) change(85-12-01,Negaret), approve(87-07-23,MCR7742), 5 8* audit(87-07-23,GDixon), install(87-08-04,MR12.1-1056): 5 9* Add network_type and tty_handle. 5 10* END HISTORY COMMENTS */ 5 11 5 12 5 13 /* format: style2 */ 5 14 5 15 /* INTERNAL INTERFACE -- SUBJECT TO CHANGE */ 5 16 5 17 dcl attach_data_ptr pointer; 5 18 dcl 1 attach_data aligned based (attach_data_ptr), 5 19 2 attach_descrip character (128) varying, 5 20 2 open_descrip character (64) varying, 5 21 2 device_id character (32) unaligned, 5 22 /* given in atd */ 5 23 2 device_used character (32) unaligned, 5 24 /* aquired by dm_ */ 5 25 2 dial_phone character (64) varying, 5 26 2 dial_id character (32) unaligned, 5 27 2 resource_desc character (256) unaligned, 5 28 2 network_type fixed bin, 5 29 2 tty_index fixed bin, 5 30 2 tty_handle fixed bin (35), 5 31 2 operation_hlock fixed bin, /* if this is nonzero detach may not free this structure */ 5 32 2 flags aligned, 5 33 3 assigned_ev_channel 5 34 bit (1) unaligned, /* we got the channel as fast channel */ 5 35 3 created_ev_channel 5 36 bit (1) unaligned, /* we got it as slow channel */ 5 37 3 have_ev_channel bit (1) unaligned, /* there is a channel to use */ 5 38 3 login_channel bit (1) unaligned, /* we are login channel */ 5 39 3 phone_given bit (1) unaligned, /* dial_out */ 5 40 3 accept_dial bit (1) unaligned, /* wait for terminal to dial */ 5 41 3 must_release bit (1) unaligned, /* we must call release channel */ 5 42 3 no_block bit (1) unaligned, /* never block */ 5 43 3 async_close bit (1) unaligned, /* close with hlock nonzero */ 5 44 3 async_detach bit (1) unaligned, /* detach_iocb with hlock nonzero */ 5 45 3 hangup bit (1) unaligned, 5 46 3 async_hangup bit (1) unaligned, /* channel was hungup (and released) by AS */ 5 47 3 have_user_hangup_proc 5 48 bit (1) unaligned, /* user has supplied a hangup procedure */ 5 49 3 pad bit (23) unaligned, 5 50 2 dial_manager_event aligned like event_wait_channel, 5 51 2 event_wait aligned like event_wait_channel, 5 52 2 user_hangup_proc, /* user supplied hangup procedure */ 5 53 3 procedure entry (pointer) variable, 5 54 3 data_ptr pointer, 5 55 2 mode_string_info aligned, 5 56 3 max_mode_length fixed bin (35), 5 57 3 mode_string char (tty_max_mode_length refer (attach_data.max_mode_length)) unaligned, 5 58 2 temp_mode_string char (tty_max_mode_length refer (attach_data.max_mode_length)) unaligned; 5 59 5 60 declare tty_max_mode_length fixed bin (21); 5 61 6 1 /* BEGIN INCLUDE FILE ... event_wait_channel.incl.pl1 */ 6 2 6 3 /* ipc_$block wait list with one channel 6 4* 6 5* Written 9-May-79 by M. N. Davidoff. 6 6**/ 6 7 6 8 declare 1 event_wait_channel aligned, 6 9 2 n_channels fixed bin initial (1), /* number of channels */ 6 10 2 pad bit (36), 6 11 2 channel_id (1) fixed bin (71); /* event channel to wait on */ 6 12 6 13 /* END INCLUDE FILE ... event_wait_channel.incl.pl1 */ 5 62 5 63 5 64 /* END OF: tty_attach_data_.incl.pl1 * * * * * */ 1136 7 1 /* BEGIN INCLUDE FILE ... tty_read_status_info.incl.pl1 7 2* 7 3* control structure for the read_status and write_status orders to tty_ 7 4* 7 5* Modified 2/1/83 by Olin Sibert to add tty_write_status_info structure in 7 6* support of lap_simplex_ MPX. 7 7**/ 7 8 7 9 7 10 /****^ HISTORY COMMENTS: 7 11* 1) change(88-07-07,Beattie), approve(88-06-27,MCR7926), 7 12* audit(88-07-22,Brunelle), install(88-08-08,MR12.2-1082): 7 13* Prepared for installation. 7 14* END HISTORY COMMENTS */ 7 15 7 16 7 17 dcl 1 tty_read_status_info aligned based (tty_read_status_info_ptr), 7 18 2 event_channel fixed bin (71), 7 19 2 input_pending bit (1); 7 20 7 21 dcl tty_read_status_info_ptr ptr; 7 22 7 23 dcl 1 tty_write_status_info aligned based (tty_write_status_info_ptr), 7 24 2 event_channel fixed bin (71), 7 25 2 output_pending bit (1); 7 26 7 27 dcl tty_write_status_info_ptr ptr; 7 28 7 29 /* END INCLUDE FILE ... tty_read_status_info.incl.pl1 */ 1137 8 1 /* BEGIN INCLUDE FILE ... tty_get_channel_info.incl.pl1 */ 8 2 8 3 /* for get_channel_info order to tty_ */ 8 4 8 5 dcl 1 tty_get_channel_info aligned based, 8 6 2 version fixed bin init (tty_get_channel_info_version), 8 7 2 devx fixed bin, 8 8 2 channel_name char (32); 8 9 8 10 dcl tty_get_channel_info_version fixed bin init (1) internal static options (constant); 8 11 8 12 /* END INCLUDE FILE ... tty_get_channel_info.incl.pl1 */ 1138 9 1 /* BEGIN INCLUDE FILE io_timeout_info.incl.pl1 */ 9 2 /* Initial version 1982.09.08 by Richard Lamson */ 9 3 9 4 declare 1 input_timeout_info based (timeout_info_ptr) aligned, 9 5 2 timeout fixed binary (71), 9 6 2 buffer_pointer pointer, 9 7 2 buffer_length fixed binary (21), 9 8 2 characters_read fixed binary (21); 9 9 9 10 declare 1 output_timeout_info based (timeout_info_ptr) aligned, 9 11 2 timeout fixed binary (71), 9 12 2 buffer_pointer pointer, 9 13 2 buffer_length fixed binary (21), 9 14 2 characters_written fixed binary (21); 9 15 9 16 declare timeout_info_ptr pointer; 9 17 9 18 /* end include file io_timeout_info.incl.pl1 */ 1139 10 1 /* START OF: tty_control_orders_info.incl.pl1 * * * * * * * * * * * * * * * * */ 10 2 /* format: style2 */ 10 3 10 4 dcl tty_old_type fixed bin based; /* terminal type number for set_type order */ 10 5 10 6 dcl 1 tty_send_initial_string_info 10 7 aligned based, /* info structure for send_initial_string order */ 10 8 2 version fixed bin, 10 9 2 initial_string char (512) varying; 10 10 10 11 dcl 1 tty_info aligned based, 10 12 2 id char (4), 10 13 2 baudrate fixed bin unal, 10 14 2 reserved bit (54) unal, 10 15 2 type fixed bin; 10 16 10 17 dcl 1 tty_modes_info based aligned, 10 18 2 mode_length fixed bin, 10 19 2 modes char (tty_modes_info.mode_length); 10 20 10 21 /* END OF: tty_control_orders_info.incl.pl1 * * * * * * * * * * * * * * * * */ 1140 11 1 /* BEGIN INCLUDE FiLE ... terminal_type_data.incl.pl1 */ 11 2 11 3 11 4 /****^ HISTORY COMMENTS: 11 5* 1) change(77-05-19,JStern), approve(), audit(), install(): 11 6* Created 11 7* Modified 8/14/79 by Robert Coren to convert to version 2 by adding 11 8* flow control parameters 11 9* 2) change(87-03-09,LJAdams), approve(87-04-03,MCR7646), 11 10* audit(87-05-05,Gilcrease), install(87-08-04,MR12.1-1056): 11 11* Change the ttd_version to ttd_version_3. Add the protocol field. 11 12* END HISTORY COMMENTS */ 11 13 11 14 11 15 dcl 1 terminal_type_data aligned based (ttdp), /* info structure for set_terminal_data order */ 11 16 2 version fixed bin, /* structure version */ 11 17 2 old_type fixed bin, /* old terminal type number, -1 => none */ 11 18 2 name char (32) unaligned, /* terminal type name */ 11 19 2 tables, 11 20 3 input_tr_ptr ptr, /* input translation table ptr */ 11 21 3 output_tr_ptr ptr, /* output translation table ptr */ 11 22 3 input_cv_ptr ptr, /* input conversion table ptr */ 11 23 3 output_cv_ptr ptr, /* output conversion table ptr */ 11 24 3 special_ptr ptr, /* special chars table ptr */ 11 25 3 delay_ptr ptr, /* delay table ptr */ 11 26 2 editing_chars unaligned, 11 27 3 erase char (1) unaligned, 11 28 3 kill char (1) unaligned, 11 29 2 framing_chars unaligned, 11 30 3 frame_begin char (1) unaligned, 11 31 3 frame_end char (1) unaligned, 11 32 2 flags unal, 11 33 3 keyboard_locking bit (1), /* ON to request keyboard locking and unlocking */ 11 34 3 input_timeout bit (1), 11 35 3 output_block_acknowledge bit (1), 11 36 3 mbz bit (15), 11 37 2 line_delimiter char (1) unal, 11 38 2 mbz bit (9) unal, 11 39 11 40 /* the remainder of this structure is only present if version is 2 or more */ 11 41 11 42 2 flow_control_chars unal, 11 43 3 input_suspend char (1), 11 44 3 input_resume char (1), 11 45 3 output_suspend_etb char (1), 11 46 3 output_resume_ack char (1), 11 47 2 output_buffer_size fixed bin, 11 48 11 49 /* the remainder of this structure is only present if version is 3 or more */ 11 50 2 protocol fixed bin; /* 0=NONE; 1=MOWSE */ 11 51 11 52 11 53 dcl ttdp ptr; /* ptr to terminal_type_data structure */ 11 54 dcl ttd_version_3 fixed bin int static options (constant) init (3); 11 55 /* current version of structure */ 11 56 11 57 11 58 /* END INCLUDE FILE ... terminal_type_data.incl.pl1 */ 1141 12 1 /* BEGIN INCLUDE FiLE ... terminal_info.incl.pl1 */ 12 2 12 3 /* Created 5/25/77 by J. Stern */ 12 4 12 5 12 6 dcl 1 terminal_info aligned based (terminal_info_ptr), /* info structure for terminal_info order */ 12 7 2 version fixed bin, /* version number of this sturcture */ 12 8 2 id char (4) unaligned, /* terminal id from answerback */ 12 9 2 term_type char (32) unaligned, /* terminal type name */ 12 10 2 line_type fixed bin, /* line type number */ 12 11 2 baud_rate fixed bin, 12 12 2 reserved (4) fixed bin; /* reserved for future use */ 12 13 12 14 12 15 dcl terminal_info_ptr ptr; 12 16 dcl terminal_info_version fixed bin int static options (constant) init (1); /* current version */ 12 17 12 18 12 19 /* END INCLUDE FILE ... terminal_info.incl.pl1 */ 1142 13 1 /* BEGIN INCLUDE FILE ... set_term_type_info.incl.pl1 */ 13 2 /* Created 7/18/77 by Robert Coren */ 13 3 /* Defines info structure for set_term_type order */ 13 4 13 5 dcl stti_version_1 fixed bin int static options (constant) init (1); 13 6 dcl sttip ptr; 13 7 13 8 dcl 1 set_term_type_info aligned based (sttip), 13 9 2 version fixed bin, 13 10 2 name char (32) unal, 13 11 2 flags unal, 13 12 3 send_initial_string bit (1), 13 13 3 set_modes bit (1), 13 14 3 ignore_line_type bit (1), 13 15 3 mbz bit (33); 13 16 13 17 /* END INCLUDE FILE ... set_term_type_info.incl.pl1 */ 1143 14 1 /* BEGIN INCLUDE FILE ... ttyp.incl.pl1 */ 14 2 14 3 dcl max_tty_type fixed bin static init (11); 14 4 14 5 dcl tty_dev_type (0:16) char (8) aligned int static init /* ASCII explanations of terminal type */ 14 6 ("Network", "1050", "2741", "TTY37", "TN300", "ARDS", "CORR2741", "TTY33", 14 7 "TTY38", "G115", "type10", "ASCII", "type12", "type13", "type14", "type15", "type16"); 14 8 14 9 /* Note that device type 0 is used for both absentee and network. Distingush some other way */ 14 10 14 11 /* END INCLUDE FILE ... ttyp.incl.pl1 */ 1144 1145 1146 end tty_io_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1155.0 tty_io_.pl1 >udd>sm>ds>w>ml>tty_io_.pl1 1132 1 03/08/85 0952.7 as_com_channel_info.incl.pl1 >ldd>incl>as_com_channel_info.incl.pl1 1133 2 06/29/79 1827.8 event_wait_info.incl.pl1 >ldd>incl>event_wait_info.incl.pl1 1134 3 05/20/83 1946.4 iocb.incl.pl1 >ldd>incl>iocb.incl.pl1 1135 4 05/23/83 1016.6 iox_entries.incl.pl1 >ldd>incl>iox_dcls.incl.pl1 1136 5 08/06/87 1013.5 tty_attach_data_.incl.pl1 >ldd>incl>tty_attach_data_.incl.pl1 5-62 6 06/29/79 1828.0 event_wait_channel.incl.pl1 >ldd>incl>event_wait_channel.incl.pl1 1137 7 08/11/88 2115.0 tty_read_status_info.incl.pl1 >ldd>incl>tty_read_status_info.incl.pl1 1138 8 01/28/81 1023.4 tty_get_channel_info.incl.pl1 >ldd>incl>tty_get_channel_info.incl.pl1 1139 9 10/19/82 2211.7 io_timeout_info.incl.pl1 >ldd>incl>io_timeout_info.incl.pl1 1140 10 06/22/81 1915.3 tty_control_orders_info.incl.pl1 >ldd>incl>tty_control_orders_info.incl.pl1 1141 11 08/06/87 1013.5 terminal_type_data.incl.pl1 >ldd>incl>terminal_type_data.incl.pl1 1142 12 06/29/77 1724.0 terminal_info.incl.pl1 >ldd>incl>terminal_info.incl.pl1 1143 13 09/01/77 1459.3 set_term_type_info.incl.pl1 >ldd>incl>set_term_type_info.incl.pl1 1144 14 08/29/75 0938.6 ttyp.incl.pl1 >ldd>incl>ttyp.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. Relative_Microseconds 000116 constant bit(2) initial packed unaligned dcl 121 set ref 1065* a_initial_string parameter varying char dcl 662 ref 659 664 a_new_modes parameter char packed unaligned dcl 46 set ref 470 476* 774* a_old_modes parameter char packed unaligned dcl 46 set ref 470 476* 774* abort_type parameter fixed bin(17,0) dcl 1098 ref 1095 1101 actual_iocb_ptr 12 based pointer level 2 dcl 3-6 ref 517 actual_iocbp 000104 automatic pointer dcl 105 set ref 234* 236* 517* 518 754* 758* 762* 766* 770* 774* addcharno builtin function dcl 102 ref 830 868 937 addr builtin function dcl 102 ref 363 363 367 367 496 501 501 544 544 579 673 673 714 714 820 855 923 971 971 1034 1034 1066 1079 1079 addrel builtin function dcl 102 ref 673 673 amt_read parameter fixed bin(21,0) dcl 1006 set ref 1001 1011* 1015* 1018* 1026 amt_to_read parameter fixed bin(21,0) dcl 1005 set ref 1001 1015* 1018* amt_trans 000115 automatic fixed bin(21,0) dcl 110 set ref 501* 942* 943* 949 970 arg_buf_len parameter fixed bin(21,0) dcl 848 in procedure "get_line" ref 845 861 863 869 arg_buf_len parameter fixed bin(21,0) dcl 46 in procedure "tty_io_" set ref 754* 758* 762* 800 807* 836 843* 905 911* arg_buf_len parameter fixed bin(21,0) dcl 916 in procedure "put_chars" ref 913 929 932 943 950 964 964 arg_buf_len parameter fixed bin(21,0) dcl 813 in procedure "get_chars" set ref 810 826 831* arg_buf_ptr parameter pointer dcl 848 in procedure "get_line" ref 845 866 arg_buf_ptr parameter pointer dcl 46 in procedure "tty_io_" set ref 754* 758* 762* 800 807* 836 843* 905 911* arg_buf_ptr parameter pointer dcl 916 in procedure "put_chars" ref 913 935 arg_buf_ptr parameter pointer dcl 813 in procedure "get_chars" ref 810 828 arg_chars_written parameter fixed bin(21,0) dcl 916 set ref 913 946* 952* 958* 967* arg_iocbp parameter pointer dcl 46 set ref 206 211 470 484 517 673* 800 836 905 arg_timeout parameter fixed bin(71,0) dcl 916 in procedure "put_chars" ref 913 923 925 956 959 arg_timeout parameter fixed bin(71,0) dcl 813 in procedure "get_chars" ref 810 820 822 arg_timeout parameter fixed bin(71,0) dcl 1047 in procedure "timer_setup" set ref 1044 1050 1065* arg_timeout parameter fixed bin(71,0) dcl 848 in procedure "get_line" ref 845 855 857 881 as_com_channel_info based structure level 1 dcl 1-9 assigned_ev_channel 237 based bit(1) level 3 packed packed unaligned dcl 5-18 set ref 251 254* async_detach 237(09) based bit(1) level 3 packed packed unaligned dcl 5-18 ref 705 725 736 async_hangup 237(11) based bit(1) level 3 packed packed unaligned dcl 5-18 ref 738 attach_data based structure level 1 dcl 5-18 set ref 748 attach_data_ptr 16 based pointer level 2 in structure "iocb" dcl 3-6 in procedure "tty_io_" ref 518 attach_data_ptr 000440 automatic pointer dcl 5-17 in procedure "tty_io_" set ref 244 245 251 253 254 256 258 259 261 262 262 274 276 285 294 345 431 432 438 440 441 442 443 443* 454 458 496 518* 533 533 557 559 562 579 581 583 589 600 623 629 633 666 670 678 703 705 708 725 736 738 748 748 780 780 820 855 881 923 962 975 993 1015 1018 1032 1038 1055 1061 1078 1078 1079 1079 1079 1101 1115 based_state based fixed bin(17,0) dcl 156 set ref 286* baud_rate 13 000401 automatic fixed bin(17,0) level 2 dcl 151 set ref 363* buffer_length 4 based fixed bin(21,0) level 2 in structure "input_timeout_info" dcl 9-4 in procedure "tty_io_" set ref 320* 328* buffer_length 4 based fixed bin(21,0) level 2 in structure "output_timeout_info" dcl 9-10 in procedure "tty_io_" set ref 338* buffer_pointer 2 based pointer level 2 in structure "output_timeout_info" dcl 9-10 in procedure "tty_io_" set ref 338* buffer_pointer 2 based pointer level 2 in structure "input_timeout_info" dcl 9-4 in procedure "tty_io_" set ref 320* 328* buffer_ptr parameter pointer dcl 1004 in procedure "read" set ref 1001 1015* 1018* buffer_ptr 000106 automatic pointer dcl 106 in procedure "tty_io_" set ref 828* 829 830* 830 831* 866* 867 868* 868 872* 935* 936 937* 937 943* buffero parameter fixed bin(21,0) dcl 985 set ref 982 993* bufferp parameter pointer dcl 985 set ref 982 993* channel 000614 automatic fixed bin(71,0) dcl 1048 set ref 1052* 1057 1062 channel_id 246 based fixed bin(71,0) array level 3 in structure "attach_data" dcl 5-18 in procedure "tty_io_" set ref 244* 253* 258* 261* 262* 276 345 454 458 975 1038 1061 channel_id 2 000336 automatic fixed bin(71,0) array level 2 in structure "timeout_event_wait" dcl 130 in procedure "tty_io_" set ref 1057* 1061* 1062* 1065* 1089* 1090* channel_id 000422 automatic fixed bin(71,0) level 2 in structure "event_message" dcl 154 in procedure "tty_io_" set ref 975 1038 channel_id 242 based fixed bin(71,0) array level 3 in structure "attach_data" dcl 5-18 in procedure "tty_io_" set ref 438 443* channel_name 2 based char(32) level 2 in structure "as_com_channel_info" dcl 1-9 in procedure "tty_io_" set ref 294* channel_name 2 based char(32) level 2 in structure "get_channel_info" dcl 145 in procedure "tty_io_" set ref 432* characters_read 5 based fixed bin(21,0) level 2 dcl 9-4 set ref 222* 320* 328* characters_written 5 based fixed bin(21,0) level 2 dcl 9-10 set ref 220* 338* charno builtin function dcl 102 ref 829 867 936 chars_trans parameter fixed bin(21,0) dcl 46 in procedure "tty_io_" set ref 754* 758* 800 803* 807* 836 839* 843* chars_trans parameter fixed bin(21,0) dcl 848 in procedure "get_line" set ref 845 860* 873* 873 chars_trans parameter fixed bin(21,0) dcl 813 in procedure "get_chars" set ref 810 825* 831* cleanup 000432 stack reference condition dcl 179 ref 227 474 491 746 805 841 909 code parameter fixed bin(35,0) dcl 985 in procedure "write_chars" set ref 982 993* 994 994* code parameter fixed bin(35,0) dcl 46 in procedure "tty_io_" set ref 206 211 234* 236* 237* 253* 258* 262* 264 264* 266* 267 267* 270* 277* 295* 296* 305* 306* 309* 311* 313* 363* 364 364* 367* 368 368* 371* 376* 377 377* 383* 384 384 384* 389* 395* 396* 404* 410* 412* 443* 445* 449* 451 451* 463* 470 476* 477* 484 501* 502 502* 508* 516* 544* 545 545* 754* 758* 762* 766* 770* 774* 787* 800 831* 832* 836 872* 875 875* 905 943* 944 947* 964* 968* 971* 972 972* 1052* 1053 1053* 1079* code parameter fixed bin(35,0) dcl 1099 in procedure "abort" set ref 1095 1101* 1102 1102* 1104* code parameter fixed bin(35,0) dcl 570 in procedure "set_modes" set ref 565 585* 587 587 596* 603* 610* code parameter fixed bin(35,0) dcl 701 in procedure "check_for_disconnect" ref 694 code parameter fixed bin(35,0) dcl 646 in procedure "send_default_initial_string" set ref 643 648* 649 653* 659 670* 671 673* code parameter fixed bin(35,0) dcl 1009 in procedure "read" set ref 1001 1015* 1018* 1020 1022* 1034* 1035 code parameter fixed bin(35,0) dcl 555 in procedure "set_default_modes" set ref 551 557* 559 562* code parameter fixed bin(35,0) dcl 1113 in procedure "call_order" set ref 1107 1115* 1116 1116* commax 000514 automatic fixed bin(21,0) dcl 571 set ref 629* 630 633 633 635 control_not_open 000110 automatic bit(1) packed unaligned dcl 107 set ref 208* 213* 234 242 299 create_ips_mask_ 000010 constant entry external dcl 64 ref 714 created_ev_channel 237(01) based bit(1) level 3 packed packed unaligned dcl 5-18 set ref 256 259* data_available 2 based bit(1) level 2 packed packed unaligned dcl 147 ref 459 data_ptr 4 based pointer level 2 in structure "hangup_proc_data" dcl 158 in procedure "tty_io_" ref 441 data_ptr 254 based pointer level 3 in structure "attach_data" dcl 5-18 in procedure "tty_io_" set ref 441* device_used 72 based char(32) level 2 packed packed unaligned dcl 5-18 ref 294 432 devx 1 based fixed bin(17,0) level 2 dcl 145 set ref 431* dial_manager_event 240 based structure level 2 dcl 5-18 entry_var based entry variable level 2 dcl 158 ref 440 error_table_$action_not_performed 000074 external static fixed bin(35,0) dcl 163 set ref 438* error_table_$bad_arg 000104 external static fixed bin(35,0) dcl 163 set ref 826* 861* 929* error_table_$io_no_permission 000122 external static fixed bin(35,0) dcl 163 set ref 738* error_table_$long_record 000106 external static fixed bin(35,0) dcl 163 set ref 887* error_table_$no_initial_string 000120 external static fixed bin(35,0) dcl 163 ref 384 653 error_table_$no_operation 000110 external static fixed bin(35,0) dcl 163 set ref 488* error_table_$not_open 000112 external static fixed bin(35,0) dcl 163 set ref 299* error_table_$null_info_ptr 000072 external static fixed bin(35,0) dcl 163 set ref 218* 283* 292* error_table_$out_of_sequence 000100 external static fixed bin(35,0) dcl 163 set ref 274* error_table_$smallarg 000102 external static fixed bin(35,0) dcl 163 ref 587 error_table_$timeout 000076 external static fixed bin(35,0) dcl 163 set ref 959* 1028* error_table_$undefined_order_request 000116 external static fixed bin(35,0) dcl 163 set ref 418* error_table_$unimplemented_version 000114 external static fixed bin(35,0) dcl 163 set ref 229* 352* 407* 429* ev_chn based fixed bin(71,0) level 2 dcl 147 set ref 454* 458* 459* event_channel based fixed bin(71,0) dcl 108 set ref 244 261 276* 345* event_message 000422 automatic structure level 1 dcl 154 set ref 971 971 1034 1034 event_wait 244 based structure level 2 dcl 5-18 set ref 496 820 855 923 event_wait_channel 000442 automatic structure level 1 dcl 6-8 event_wait_info based structure level 1 dcl 2-7 event_wait_ptr 000112 automatic pointer dcl 109 set ref 496* 820* 822* 855* 857* 923* 925* 971* 1028 1034* 1066* flags 237 based structure level 2 in structure "attach_data" dcl 5-18 in procedure "tty_io_" flags 11 based structure level 2 in structure "set_term_type_info" packed packed unaligned dcl 13-8 in procedure "tty_io_" get_channel_info based structure level 1 dcl 145 get_com_channel_info_ 000012 constant entry external dcl 65 ref 295 get_line_called parameter bit(1) packed unaligned dcl 1008 ref 1001 1015 hangup_proc_data based structure level 1 dcl 158 have_ev_channel 237(02) based bit(1) level 3 packed packed unaligned dcl 5-18 set ref 245* 274 have_user_hangup_proc 237(12) based bit(1) level 3 packed packed unaligned dcl 5-18 set ref 442* hcs_$delete_channel 000014 constant entry external dcl 66 ref 253 hcs_$reset_ips_mask 000020 constant entry external dcl 67 ref 729 hcs_$set_ips_mask 000016 constant entry external dcl 67 ref 722 hcs_$tty_abort 000022 constant entry external dcl 71 ref 1101 hcs_$tty_event 000024 constant entry external dcl 72 ref 262 hcs_$tty_get_line 000026 constant entry external dcl 73 ref 1015 hcs_$tty_order 000030 constant entry external dcl 75 ref 1079 1115 hcs_$tty_read 000032 constant entry external dcl 76 ref 1018 hcs_$tty_state 000034 constant entry external dcl 78 ref 285 708 hcs_$tty_write 000036 constant entry external dcl 79 ref 993 i 000114 automatic fixed bin(21,0) dcl 110 set ref 497* 499 504* 504 ignore_line_type 11(02) based bit(1) level 3 packed packed unaligned dcl 13-8 ref 356 index builtin function dcl 102 ref 629 info_ptr parameter pointer dcl 46 in procedure "tty_io_" set ref 206 211 218 220 222 234* 236* 244 261 276 283 286 292 294 295* 305* 318 326 335 345 351 401 407 409 418 418 421 429 431 432 440 441 443 449* 454 458 459 459 766* info_ptr parameter pointer dcl 1111 in procedure "call_order" set ref 1107 1115* initial_string 000117 automatic varying char(512) dcl 112 in procedure "tty_io_" set ref 409* 410* 648* 651 664* 673 673 673 673 initial_string 1 based varying char(512) level 2 in structure "send_initial_string_info" dcl 142 in procedure "tty_io_" ref 409 input_timeout_info based structure level 1 dcl 9-4 iocb based structure level 1 dcl 3-6 iox_$control 000124 constant entry external dcl 4-8 ref 766 iox_$get_chars 000126 constant entry external dcl 4-8 ref 754 iox_$get_line 000130 constant entry external dcl 4-8 ref 758 iox_$modes 000132 constant entry external dcl 4-8 ref 774 iox_$position 000134 constant entry external dcl 4-8 ref 770 iox_$put_chars 000136 constant entry external dcl 4-8 ref 762 iox_op_in_progress 000116 automatic fixed bin(17,0) dcl 111 set ref 534* 752 ipc_$block 000040 constant entry external dcl 81 ref 971 1034 ipc_$create_ev_chn 000042 constant entry external dcl 82 ref 1052 ipc_$decl_ev_call_chn 000044 constant entry external dcl 83 ref 443 ipc_$delete_ev_chn 000046 constant entry external dcl 84 ref 258 1090 length builtin function dcl 102 ref 501 501 594 600 621 629 633 633 635 651 673 673 line_type 12 000401 automatic fixed bin(17,0) level 2 dcl 151 set ref 358 login_channel 237(03) based bit(1) level 3 packed packed unaligned dcl 5-18 ref 703 ltype 000320 automatic fixed bin(17,0) dcl 113 set ref 356* 358* 363* 422* mask_to_reset 000541 automatic bit(36) dcl 700 set ref 722* 729* mask_to_set 000540 automatic bit(36) dcl 699 set ref 714* 716* 716 722* max_mode_length 256 based fixed bin(35,0) level 3 dcl 5-18 set ref 557 557 557 559 559 562 562 562 581 583 589 600 623 629 633 666 666 670 670 670 678 678 678 748 748 1078 1078 1078 max_tty_type constant fixed bin(17,0) initial dcl 14-3 ref 418 mod builtin function dcl 102 ref 829 867 936 mode parameter fixed bin(17,0) dcl 46 set ref 484 488 770* mode_string 257 based char level 3 packed packed unaligned dcl 5-18 set ref 581* 583* 589 600 623 629 633 1078* mode_string_info 256 based structure level 2 dcl 5-18 set ref 579 1079 1079 modes_need_restoration 000324 automatic bit(1) dcl 115 set ref 520* 668* 680* 1076 modes_ptr 000322 automatic pointer dcl 114 set ref 579* 585* n_channels 000442 automatic fixed bin(17,0) initial level 2 in structure "event_wait_channel" dcl 6-8 in procedure "tty_io_" set ref 6-8* n_channels 000336 automatic fixed bin(17,0) level 2 in structure "timeout_event_wait" dcl 130 in procedure "tty_io_" set ref 1058* 1063* n_to_write parameter fixed bin(21,0) dcl 985 set ref 982 993* n_wrote parameter fixed bin(21,0) dcl 985 set ref 982 993* name 1 based char(32) level 2 packed packed unaligned dcl 13-8 ref 355 new_mode_prefix parameter char packed unaligned dcl 568 ref 565 575 581 new_modes parameter char packed unaligned dcl 568 ref 565 581 583 nl_returned 000325 automatic bit(1) packed unaligned dcl 116 set ref 504 878 1015* no_block 237(07) based bit(1) level 3 packed packed unaligned dcl 5-18 ref 881 962 1032 1055 no_of_records parameter fixed bin(21,0) dcl 46 set ref 484 488 493 499 770* null builtin function dcl 102 ref 218 266 266 283 292 401 519 521 791 795 822 857 925 1028 1087 1125 num_read 000327 automatic fixed bin(21,0) dcl 118 set ref 872* 873 883 884 num_to_read 000326 automatic fixed bin(21,0) dcl 117 set ref 869* 871 872* 884* 884 offset 000330 automatic fixed bin(21,0) dcl 119 in procedure "tty_io_" set ref 829* 830 831* 867* 868 872* 883* 883 936* 937 943* 970* 970 offset parameter fixed bin(21,0) dcl 1007 in procedure "read" set ref 1001 1015* 1018* old_modes parameter char packed unaligned dcl 568 set ref 565 589* 594 604* 621 623* 629 630* 633 633* 633 635 635* old_type based fixed bin(17,0) dcl 137 ref 418 418 421 operation_hlock 236 based fixed bin(17,0) level 2 dcl 5-18 set ref 533* 533 748 780* 780 order parameter char packed unaligned dcl 1110 in procedure "call_order" set ref 1107 1115* order parameter char packed unaligned dcl 46 in procedure "tty_io_" set ref 206 211 215 215 215 220 229 232 232 234* 236* 240 240 272 272 281 290 303 309 311 313 316 324 333 343 349 392 399 415 415 427 436 449* 454 456 766* output_timeout_info based structure level 1 dcl 9-10 prefix parameter char packed unaligned dcl 554 set ref 551 562* prefix_in_use 000515 automatic bit(1) dcl 572 set ref 575* 577* 581 prior 6 based fixed bin(17,0) level 2 dcl 158 set ref 443* procedure 250 based entry variable level 3 dcl 5-18 set ref 440* r_code parameter fixed bin(35,0) dcl 785 ref 783 787 returned_length 000516 automatic fixed bin(21,0) dcl 573 set ref 600* 601 621 reverse builtin function dcl 102 ref 629 rtrim builtin function dcl 102 ref 600 scratch_buffer based char(2000) dcl 123 set ref 495 501 501 501 501 795 1125 scratch_buffer_ptr 000332 automatic pointer dcl 122 set ref 495* 501 501 501 501 521* 795 795 1125 1125 send_initial_string 11 based bit(1) level 3 packed packed unaligned dcl 13-8 ref 381 send_initial_string_info based structure level 1 dcl 142 set_modes 11(01) based bit(1) level 3 packed packed unaligned dcl 13-8 ref 374 set_term_type_info based structure level 1 dcl 13-8 set_type_order 000334 automatic bit(1) dcl 127 set ref 359* 371 423* sis_version constant fixed bin(17,0) initial dcl 124 ref 407 state 000335 automatic fixed bin(17,0) dcl 128 in procedure "tty_io_" set ref 262* 266* 305* 367* 449* 544* 585* 943* 1015* 1018* 1079* 1101* state parameter fixed bin(17,0) dcl 1112 in procedure "call_order" set ref 1107 1115* statex parameter fixed bin(17,0) dcl 985 set ref 982 993* status_struc based structure level 1 dcl 147 stti_version_1 constant fixed bin(17,0) initial dcl 13-5 ref 352 sttip 000450 automatic pointer dcl 13-6 set ref 351* 352 355 356 374 381 substr builtin function dcl 102 set ref 629 633* 633 635* sus_trm_names 000050 constant char(32) initial array packed unaligned dcl 126 set ref 714 714 t_info 000401 automatic structure level 1 dcl 151 set ref 544 544 temp_code 000101 automatic fixed bin(35,0) dcl 61 in procedure "tty_io_" set ref 285* temp_code 000537 automatic fixed bin(35,0) dcl 698 in procedure "check_for_disconnect" set ref 708* 710 temp_mode_string based char level 2 packed packed unaligned dcl 5-18 set ref 557* 559 562* 666* 670* 678* 1078 temp_state 000536 automatic fixed bin(17,0) dcl 697 in procedure "check_for_disconnect" set ref 708* temp_state 000102 automatic fixed bin(17,0) dcl 62 in procedure "tty_io_" set ref 285* 286 term_type 2 000401 automatic char(32) level 2 packed packed unaligned dcl 151 set ref 355* 363* 421* 557* 648* terminal_info based structure level 1 dcl 12-6 terminal_info_version constant fixed bin(17,0) initial dcl 12-16 ref 542 terminal_type_data based structure level 1 dcl 11-15 timed_out 000100 automatic bit(1) dcl 60 set ref 940* 959 975* 1013* 1028 1038* timeout based fixed bin(71,0) level 2 in structure "input_timeout_info" dcl 9-4 in procedure "tty_io_" set ref 319* 320* 327* 328* timeout based fixed bin(71,0) level 2 in structure "output_timeout_info" dcl 9-10 in procedure "tty_io_" set ref 336* 338* timeout_event_wait 000336 automatic structure level 1 dcl 130 set ref 1066 timeout_info_ptr 000446 automatic pointer dcl 9-16 set ref 318* 319 320 320 320 320 326* 327 328 328 328 328 335* 336 338 338 338 338 519* 791 1087 timer_manager_$alarm_wakeup 000050 constant entry external dcl 85 ref 459 1065 timer_manager_$reset_alarm_wakeup 000052 constant entry external dcl 87 ref 1089 timer_manager_$sleep 000054 constant entry external dcl 89 ref 726 total_amt_trans 000344 automatic fixed bin(21,0) dcl 135 set ref 938* 943 946 949* 949 950 952 958 964 964 967 ttd 000346 automatic structure level 1 dcl 139 set ref 363 363 367 367 ttd_version_3 constant fixed bin(17,0) initial dcl 11-54 ref 361 ttt_info_$initial_string 000066 constant entry external dcl 98 ref 648 ttt_info_$modes 000070 constant entry external dcl 100 ref 557 ttt_info_$terminal_data 000064 constant entry external dcl 96 ref 363 tty_$tty_as_signal_handler 000056 constant entry external dcl 90 ref 443 443 tty_dev_type 000006 constant char(8) initial array dcl 14-5 ref 421 tty_get_channel_info based structure level 1 dcl 8-5 tty_index 234 based fixed bin(17,0) level 2 dcl 5-18 set ref 262* 285* 431 708* 993* 1015* 1018* 1079* 1101* 1115* tty_io_call_control_ 000060 constant entry external dcl 92 ref 236 tty_io_call_control_$not_open 000062 constant entry external dcl 92 ref 234 tty_send_initial_string_info based structure level 1 dcl 10-6 user_hangup_proc 250 based structure level 2 dcl 5-18 version 000401 automatic fixed bin(17,0) level 2 in structure "t_info" dcl 151 in procedure "tty_io_" set ref 542* version based fixed bin(17,0) level 2 in structure "send_initial_string_info" dcl 142 in procedure "tty_io_" ref 407 version based fixed bin(17,0) initial level 2 in structure "get_channel_info" dcl 145 in procedure "tty_io_" ref 429 version 000346 automatic fixed bin(17,0) level 2 in structure "ttd" dcl 139 in procedure "tty_io_" set ref 361* version based fixed bin(17,0) level 2 in structure "set_term_type_info" dcl 13-8 in procedure "tty_io_" ref 352 which_op parameter fixed bin(17,0) dcl 530 ref 527 534 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AS_COM_CHANNEL_INFO_VERSION_1 internal static char(8) initial dcl 1-30 as_com_channel_info_ptr automatic pointer dcl 1-8 event_wait_info_ptr automatic pointer dcl 2-5 iox_$attach_loud 000000 constant entry external dcl 4-8 iox_$attach_name 000000 constant entry external dcl 4-8 iox_$attach_ptr 000000 constant entry external dcl 4-8 iox_$close 000000 constant entry external dcl 4-8 iox_$close_file 000000 constant entry external dcl 4-8 iox_$delete_record 000000 constant entry external dcl 4-8 iox_$destroy_iocb 000000 constant entry external dcl 4-8 iox_$detach 000000 constant entry external dcl 4-8 iox_$detach_iocb 000000 constant entry external dcl 4-8 iox_$err_no_operation 000000 constant entry external dcl 4-8 iox_$err_not_attached 000000 constant entry external dcl 4-8 iox_$err_not_closed 000000 constant entry external dcl 4-8 iox_$err_not_open 000000 constant entry external dcl 4-8 iox_$error_output external static pointer dcl 4-41 iox_$find_iocb 000000 constant entry external dcl 4-8 iox_$find_iocb_n 000000 constant entry external dcl 4-8 iox_$iocb_version_sentinel external static char(4) dcl 3-51 iox_$look_iocb 000000 constant entry external dcl 4-8 iox_$move_attach 000000 constant entry external dcl 4-8 iox_$open 000000 constant entry external dcl 4-8 iox_$open_file 000000 constant entry external dcl 4-8 iox_$propagate 000000 constant entry external dcl 4-8 iox_$read_key 000000 constant entry external dcl 4-8 iox_$read_length 000000 constant entry external dcl 4-8 iox_$read_record 000000 constant entry external dcl 4-8 iox_$rewrite_record 000000 constant entry external dcl 4-8 iox_$seek_key 000000 constant entry external dcl 4-8 iox_$user_input external static pointer dcl 4-41 iox_$user_io external static pointer dcl 4-41 iox_$user_output external static pointer dcl 4-41 iox_$write_record 000000 constant entry external dcl 4-8 terminal_info_ptr automatic pointer dcl 12-15 ttdp automatic pointer dcl 11-53 tty_get_channel_info_version internal static fixed bin(17,0) initial dcl 8-10 tty_info based structure level 1 dcl 10-11 tty_max_mode_length automatic fixed bin(21,0) dcl 5-60 tty_modes_info based structure level 1 dcl 10-17 tty_old_type based fixed bin(17,0) dcl 10-4 tty_read_status_info based structure level 1 dcl 7-17 tty_read_status_info_ptr automatic pointer dcl 7-21 tty_write_status_info based structure level 1 dcl 7-23 tty_write_status_info_ptr automatic pointer dcl 7-27 NAMES DECLARED BY EXPLICIT CONTEXT. CONTROL_JOIN 000376 constant label dcl 215 ref 209 IOX_OPERATION 000000 constant label array(6) dcl 754 ref 752 TYPE 001532 constant label dcl 361 ref 424 abort 005564 constant entry internal dcl 1095 ref 309 311 313 call_order 005630 constant entry internal dcl 1107 ref 266 305 367 449 544 585 check_async 004400 constant entry internal dcl 733 ref 535 974 1037 check_for_disconnect 004257 constant entry internal dcl 694 ref 264 267 994 1022 1102 1116 clean_up 005707 constant entry internal dcl 1120 ref 227 474 491 805 841 909 control 000356 constant entry external dcl 211 control_not_open 000332 constant entry external dcl 206 fake_operation_and_return 002652 constant label dcl 746 ref 705 731 736 get_chars 004442 constant entry internal dcl 810 ref 328 807 get_line 004540 constant entry internal dcl 845 ref 320 843 get_terminal_info 003400 constant entry internal dcl 539 ref 354 394 403 420 modes 002372 constant entry external dcl 470 modes_cleanup 005450 constant entry internal dcl 1070 ref 794 1124 proper_io_return 004435 constant entry internal dcl 783 ref 218 229 237 270 274 277 283 287 292 296 299 306 346 352 364 368 371 377 389 396 407 412 418 429 433 438 445 451 463 477 488 502 508 545 738 826 832 861 863 875 878 881 887 929 932 947 953 959 968 972 1028 1053 1104 proper_io_return_label_ 003063 constant label dcl 791 ref 788 put_chars 004712 constant entry internal dcl 913 ref 338 911 read 005204 constant entry internal dcl 1001 ref 501 831 872 send_default_initial_string 004035 constant entry internal dcl 643 ref 383 404 send_initial_string 004074 constant entry internal dcl 659 ref 410 set_default_modes 003450 constant entry internal dcl 551 ref 376 395 set_modes 003567 constant entry internal dcl 565 ref 476 562 670 678 set_up 003350 constant entry internal dcl 513 ref 532 set_up_io 003366 constant entry internal dcl 527 ref 226 473 487 804 840 908 sis_common 004122 constant label dcl 666 ref 657 timer_cleanup 005530 constant entry internal dcl 1084 ref 791 1123 timer_setup 005363 constant entry internal dcl 1044 ref 319 327 336 tty_io_ 000316 constant entry external dcl 42 tty_io_$get_chars 003117 constant entry external dcl 800 tty_io_$get_line 003202 constant entry external dcl 836 tty_io_$position 002506 constant entry external dcl 484 tty_io_$put_chars 003270 constant entry external dcl 905 ref 673 unlock_hlock 004423 constant entry internal dcl 778 ref 750 797 1127 write_chars 005143 constant entry internal dcl 982 ref 943 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6702 7042 5776 6712 Length 7642 5776 140 564 703 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME tty_io_ 790 external procedure is an external procedure. on unit on line 227 64 on unit on unit on line 474 64 on unit on unit on line 491 64 on unit set_up internal procedure shares stack frame of external procedure tty_io_. set_up_io internal procedure shares stack frame of external procedure tty_io_. get_terminal_info internal procedure shares stack frame of external procedure tty_io_. set_default_modes internal procedure shares stack frame of external procedure tty_io_. set_modes internal procedure shares stack frame of external procedure tty_io_. send_default_initial_string internal procedure shares stack frame of external procedure tty_io_. check_for_disconnect internal procedure shares stack frame of external procedure tty_io_. unlock_hlock 64 internal procedure is called by several nonquick procedures. proper_io_return internal procedure shares stack frame of external procedure tty_io_. on unit on line 805 64 on unit get_chars internal procedure shares stack frame of external procedure tty_io_. on unit on line 841 64 on unit get_line internal procedure shares stack frame of external procedure tty_io_. on unit on line 909 64 on unit put_chars internal procedure shares stack frame of external procedure tty_io_. write_chars internal procedure shares stack frame of external procedure tty_io_. read internal procedure shares stack frame of external procedure tty_io_. timer_setup internal procedure shares stack frame of external procedure tty_io_. modes_cleanup 90 internal procedure is called by several nonquick procedures. timer_cleanup 76 internal procedure is called by several nonquick procedures. abort internal procedure shares stack frame of external procedure tty_io_. call_order internal procedure shares stack frame of external procedure tty_io_. clean_up 64 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME tty_io_ 000100 timed_out tty_io_ 000101 temp_code tty_io_ 000102 temp_state tty_io_ 000104 actual_iocbp tty_io_ 000106 buffer_ptr tty_io_ 000110 control_not_open tty_io_ 000112 event_wait_ptr tty_io_ 000114 i tty_io_ 000115 amt_trans tty_io_ 000116 iox_op_in_progress tty_io_ 000117 initial_string tty_io_ 000320 ltype tty_io_ 000322 modes_ptr tty_io_ 000324 modes_need_restoration tty_io_ 000325 nl_returned tty_io_ 000326 num_to_read tty_io_ 000327 num_read tty_io_ 000330 offset tty_io_ 000332 scratch_buffer_ptr tty_io_ 000334 set_type_order tty_io_ 000335 state tty_io_ 000336 timeout_event_wait tty_io_ 000344 total_amt_trans tty_io_ 000346 ttd tty_io_ 000401 t_info tty_io_ 000422 event_message tty_io_ 000440 attach_data_ptr tty_io_ 000442 event_wait_channel tty_io_ 000446 timeout_info_ptr tty_io_ 000450 sttip tty_io_ 000514 commax set_modes 000515 prefix_in_use set_modes 000516 returned_length set_modes 000536 temp_state check_for_disconnect 000537 temp_code check_for_disconnect 000540 mask_to_set check_for_disconnect 000541 mask_to_reset check_for_disconnect 000614 channel timer_setup THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp call_ext_in call_ext_out_desc call_ext_out call_int_this call_int_other return_mac mdfx1 enable_op shorten_stack ext_entry ext_entry_desc int_entry alloc_storage op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. create_ips_mask_ get_com_channel_info_ hcs_$delete_channel hcs_$reset_ips_mask hcs_$set_ips_mask hcs_$tty_abort hcs_$tty_event hcs_$tty_get_line hcs_$tty_order hcs_$tty_read hcs_$tty_state hcs_$tty_write iox_$control iox_$get_chars iox_$get_line iox_$modes iox_$position iox_$put_chars ipc_$block ipc_$create_ev_chn ipc_$decl_ev_call_chn ipc_$delete_ev_chn timer_manager_$alarm_wakeup timer_manager_$reset_alarm_wakeup timer_manager_$sleep ttt_info_$initial_string ttt_info_$modes ttt_info_$terminal_data tty_$tty_as_signal_handler tty_io_call_control_ tty_io_call_control_$not_open THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$bad_arg error_table_$io_no_permission error_table_$long_record error_table_$no_initial_string error_table_$no_operation error_table_$not_open error_table_$null_info_ptr error_table_$out_of_sequence error_table_$smallarg error_table_$timeout error_table_$undefined_order_request error_table_$unimplemented_version LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 6 8 000311 42 000315 44 000324 206 000325 208 000351 209 000353 211 000354 213 000375 215 000376 218 000415 220 000430 222 000443 226 000446 227 000452 229 000474 232 000512 234 000525 236 000555 237 000602 240 000610 242 000623 244 000625 245 000644 246 000646 251 000647 253 000653 254 000664 255 000667 256 000670 258 000673 259 000704 261 000707 262 000714 264 000731 266 000741 267 000771 270 001001 272 001007 274 001022 276 001035 277 001042 281 001050 283 001057 285 001072 286 001106 287 001112 290 001115 292 001124 294 001137 295 001146 296 001157 299 001165 303 001176 305 001205 306 001233 309 001241 311 001262 313 001303 316 001324 318 001333 319 001336 320 001344 324 001361 326 001370 327 001373 328 001401 333 001416 335 001425 336 001430 338 001436 343 001453 345 001462 346 001466 349 001471 351 001500 352 001503 354 001515 355 001516 356 001522 358 001527 359 001531 361 001532 363 001534 364 001566 367 001576 368 001632 371 001642 374 001652 376 001656 377 001674 381 001704 383 001710 384 001716 389 001724 392 001732 394 001741 395 001742 396 001763 399 001771 401 002000 403 002004 404 002005 405 002013 407 002014 409 002027 410 002037 412 002053 415 002061 418 002074 420 002111 421 002112 422 002122 423 002123 424 002125 427 002126 429 002132 431 002145 432 002153 433 002156 436 002161 438 002170 440 002202 441 002212 442 002214 443 002216 445 002243 449 002251 451 002277 454 002307 456 002322 458 002327 459 002333 463 002356 470 002364 473 002416 474 002422 476 002444 477 002472 484 002500 487 002517 488 002523 491 002537 493 002561 495 002564 496 002570 497 002573 499 002574 501 002600 502 002627 504 002637 506 002643 508 002644 746 002652 748 002653 750 002676 752 002702 754 002704 756 002724 758 002725 760 002745 762 002746 764 002764 766 002765 768 003013 770 003014 772 003032 774 003033 776 003062 791 003063 794 003073 795 003077 797 003105 798 003111 800 003112 803 003130 804 003132 805 003136 807 003160 836 003177 839 003213 840 003215 841 003221 843 003243 905 003262 908 003301 909 003305 911 003327 1146 003347 513 003350 516 003351 517 003352 518 003357 519 003361 520 003363 521 003364 522 003365 527 003366 532 003370 533 003371 534 003373 535 003376 536 003377 539 003400 542 003401 544 003403 545 003437 547 003447 551 003450 557 003461 559 003514 562 003536 563 003566 565 003567 575 003612 577 003624 579 003625 581 003630 583 003656 585 003666 587 003714 589 003722 591 003731 594 003732 596 003734 597 003735 600 003736 601 003755 603 003756 604 003757 605 003764 610 003765 621 003766 623 003770 624 003776 629 003777 630 004011 633 004017 635 004025 638 004034 643 004035 648 004041 649 004062 651 004065 653 004067 654 004072 657 004073 659 004074 664 004110 666 004122 668 004135 670 004137 671 004171 673 004174 678 004220 680 004255 681 004256 694 004257 703 004261 705 004266 708 004271 710 004304 714 004307 716 004326 722 004331 725 004342 726 004346 727 004363 729 004364 731 004377 733 004400 736 004401 738 004405 740 004420 742 004421 778 004422 780 004430 781 004434 783 004435 787 004437 788 004441 810 004442 820 004444 822 004452 825 004455 826 004456 828 004467 829 004473 830 004504 831 004507 832 004531 834 004537 845 004540 855 004542 857 004550 860 004553 861 004554 863 004565 866 004573 867 004577 868 004610 869 004613 871 004615 872 004620 873 004642 875 004645 878 004655 881 004663 883 004675 884 004677 885 004701 887 004702 888 004711 913 004712 923 004714 925 004722 929 004725 932 004736 935 004744 936 004750 937 004761 938 004764 940 004765 942 004766 943 004767 944 005013 946 005015 947 005020 949 005026 950 005030 952 005034 953 005035 956 005040 958 005043 959 005045 961 005060 962 005061 964 005065 967 005073 968 005075 970 005103 971 005105 972 005122 974 005132 975 005133 979 005141 980 005142 982 005143 993 005145 994 005172 996 005203 1001 005204 1011 005206 1013 005207 1015 005210 1018 005245 1020 005271 1022 005274 1023 005302 1026 005303 1028 005306 1032 005323 1034 005330 1035 005346 1037 005352 1038 005353 1040 005361 1041 005362 1044 005363 1050 005365 1052 005370 1053 005401 1055 005411 1057 005415 1058 005417 1059 005421 1061 005422 1062 005424 1063 005426 1065 005430 1066 005444 1067 005446 1070 005447 1076 005455 1078 005460 1079 005473 1081 005526 1084 005527 1087 005535 1089 005542 1090 005550 1091 005563 1095 005564 1101 005566 1102 005607 1104 005620 1105 005627 1107 005630 1115 005641 1116 005674 1118 005705 1120 005706 1123 005714 1124 005721 1125 005726 1127 005735 1128 005742 ----------------------------------------------------------- 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