?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Interactive Facility : Commands and Functions' ??
MODULE ifm$interactive_commands;

{
{ PURPOSE:
{   This module contains the processors of interactive facility commands and
{   functions.
{

?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clc$standard_file_names
*copyc clt$data_value
*copyc clt$parameter_list
*copyc clt$work_area
*copyc fsc$local
*copyc fst$temporary_file_path
*copyc ife$error_codes
*copyc jmt$user_supplied_name
*copyc osc$timesharing
*copyc oss$job_paged_literal
*copyc ost$status
?? POP ??
*copyc amp$flush
*copyc clp$build_path_subtitle
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_data_to_string
*copyc clp$convert_integer_to_string
*copyc clp$convert_string_to_file
*copyc clp$evaluate_parameters
*copyc clp$get_fs_path_elements
*copyc clp$get_path_name
*copyc clp$get_system_file_id
*copyc clp$get_work_area
*copyc clp$horizontal_tab_display
*copyc clp$make_application_value
*copyc clp$make_boolean_value
*copyc clp$make_char_value
*copyc clp$make_file_value
*copyc clp$make_integer_value
*copyc clp$make_keyword_value
*copyc clp$make_list_value
*copyc clp$make_name_value
*copyc clp$make_range_value
*copyc clp$make_record_value
*copyc clp$make_sized_string_value
*copyc clp$make_string_value
*copyc clp$make_trimmed_string_value
*copyc clp$make_unspecified_value
*copyc clp$new_display_line
*copyc clp$open_display_reference
*copyc clp$put_data_representation
*copyc clp$put_display
*copyc clp$put_job_command_response
*copyc clp$put_partial_display
*copyc clp$reset_for_next_display_page
*copyc clp$sort_record_fields
*copyc clp$trimmed_string_size
*copyc clv$nil_display_control
*copyc clv$standard_files
*copyc fsp$path_element
*copyc ifp$change_term_conn_attributes
*copyc ifp$change_term_conn_defaults
*copyc ifp$change_terminal_attributes
*copyc ifp$get_network_identifier
*copyc ifp$get_telnet_connection_limit
*copyc ifp$get_term_conn_attributes
*copyc ifp$get_term_conn_defaults
*copyc ifp$get_terminal_attributes
*copyc iip$vtp_create_cdcnet_connect
*copyc jmp$attach_timesharing_job
*copyc jmp$detach_timesharing_job
*copyc jmp$get_job_attributes
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc rmp$request_terminal
?? OLDTITLE, EJECT ??
  CONST
    max_host_parameter_length = 63;

  TYPE
    t$term_conn_type = (c$term_conn_attributes, c$term_conn_defaults);

  VAR
    attribute_undefined_message: [STATIC, READ, oss$job_paged_literal] string (28) :=
          'Undefined on current network';

?? TITLE := 'terminal_attribute_table', EJECT ??

{ This table is used to determine a terminal attribute's ordinal given its
{ keyword.  The entries in this table must be in alphabetical order by keyword.

  CONST
    max_terminal_attributes = 34;

  VAR
    terminal_attribute_table: [STATIC, READ, oss$job_paged_literal] array [1 .. max_terminal_attributes] of
          record
      name: clt$keyword,
      key: ift$terminal_attribute_keys,
    recend := [
          {} ['ATTENTION_CHARACTER            ', ifc$attention_character],
          {} ['BACKSPACE_CHARACTER            ', ifc$backspace_character],
          {} ['BEGIN_LINE_CHARACTER           ', ifc$begin_line_character],
          {} ['CANCEL_LINE_CHARACTER          ', ifc$cancel_line_character],
          {} ['CARRIAGE_RETURN_DELAY          ', ifc$carriage_return_delay],
          {} ['CARRIAGE_RETURN_SEQUENCE       ', ifc$carriage_return_sequence],
          {} ['CHARACTER_FLOW_CONTROL         ', ifc$character_flow_control],
          {} ['CODE_SET                       ', ifc$code_set],
          {} ['CONTROL_CODE_REPLACEMENT       ', ifc$control_code_replacement],
          {} ['ECHOPLEX                       ', ifc$echoplex],
          {} ['END_LINE_CHARACTER             ', ifc$end_line_character],
          {} ['END_LINE_POSITIONING           ', ifc$end_line_positioning],
          {} ['END_OUTPUT_SEQUENCE            ', ifc$end_output_sequence],
          {} ['END_PAGE_ACTION                ', ifc$end_page_action],
          {} ['END_PARTIAL_CHARACTER          ', ifc$end_partial_character],
          {} ['END_PARTIAL_POSITIONING        ', ifc$end_partial_positioning],
          {} ['FOLD_LINE                      ', ifc$fold_line],
          {} ['FORM_FEED_DELAY                ', ifc$form_feed_delay],
          {} ['FORM_FEED_SEQUENCE             ', ifc$form_feed_sequence],
          {} ['FUNCTION_KEY_CLASS             ', ifc$function_key_class],
          {} ['HOLD_PAGE                      ', ifc$hold_page],
          {} ['HOLD_PAGE_OVER                 ', ifc$hold_page_over],
          {} ['LINE_FEED_DELAY                ', ifc$line_feed_delay],
          {} ['LINE_FEED_SEQUENCE             ', ifc$line_feed_sequence],
          {} ['NETWORK_COMMAND_CHARACTER      ', ifc$network_command_character],
          {} ['PAGE_LENGTH                    ', ifc$page_length],
          {} ['PAGE_WIDTH                     ', ifc$page_width],
          {} ['PARITY                         ', ifc$parity],
          {} ['PAUSE_BREAK_CHARACTER          ', ifc$pause_break_character],
          {} ['STATUS_ACTION                  ', ifc$status_action],
          {} ['TERMINAL_CLASS                 ', ifc$terminal_class],
          {} ['TERMINAL_MODEL                 ', ifc$terminal_model],
          {} ['TERMINAL_NAME                  ', ifc$terminal_name],
          {} ['TERMINATE_BREAK_CHARACTER      ', ifc$terminate_break_character]];

?? TITLE := 'connection_attribute_table', EJECT ??

{ This table is used to determine a terminal connection attribute's ordinal
{ given its keyword.  The entries in this table must be in alphabetical order
{ by keyword.

  CONST
    max_connection_attributes = 21;

  VAR
    connection_attribute_table: [STATIC, READ, oss$job_paged_literal] array
          [1 .. max_connection_attributes] of record
      name: clt$keyword,
      key: ift$connection_attribute_keys,
    recend := [
          {} ['ATTENTION_CHARACTER_ACTION     ', ifc$attention_character_action],
          {} ['BREAK_KEY_ACTION               ', ifc$break_key_action],
          {} ['END_OF_INFORMATION             ', ifc$end_of_information],
          {} ['INPUT_BLOCK_SIZE               ', ifc$input_block_size],
          {} ['INPUT_EDITING_MODE             ', ifc$input_editing_mode],
          {} ['INPUT_OUTPUT_MODE              ', ifc$input_output_mode],
          {} ['INPUT_TIMEOUT                  ', ifc$input_timeout],
          {} ['INPUT_TIMEOUT_LENGTH           ', ifc$input_timeout_length],
          {} ['INPUT_TIMEOUT_PURGE            ', ifc$input_timeout_purge],
          {} ['PARTIAL_CHARACTER_FORWARDING   ', ifc$partial_char_forwarding],
          {} ['PROMPT_FILE                    ', ifc$prompt_file],
          {} ['PROMPT_STRING                  ', ifc$prompt_string],
          {} ['STORE_BACKSPACE_CHARACTER      ', ifc$store_backspace_character],
          {} ['STORE_NULS_DELS                ', ifc$store_nuls_dels],
          {} ['TRANSPARENT_CHARACTER_MODE     ', ifc$trans_character_mode],
          {} ['TRANSPARENT_FORWARD_CHARACTER  ', ifc$trans_forward_character],
          {} ['TRANSPARENT_LENGTH_MODE        ', ifc$trans_length_mode],
          {} ['TRANSPARENT_MESSAGE_LENGTH     ', ifc$trans_message_length],
          {} ['TRANSPARENT_PROTOCOL_MODE      ', ifc$trans_protocol_mode],
          {} ['TRANSPARENT_TERMINATE_CHARACTER', ifc$trans_terminate_character],
          {} ['TRANSPARENT_TIMEOUT_MODE       ', ifc$trans_timeout_mode]];

?? TITLE := 'change_term_conn', EJECT ??

  PROCEDURE change_term_conn
    (    pvt: ^array [1 .. * ] of clt$parameter_value;
         term_conn_type: t$term_conn_type;
     VAR status: ost$status);

    VAR
      attributes: ^ift$connection_attributes,
      attributes_area: ^SEQ ( * ),
      attribute_count: integer,
      attribute_limit: integer,
      count: clt$list_size,
      file: clt$file,
      i: integer,
      lfn: amt$local_file_name,
      node: ^clt$data_value;

    VAR
      p$terminal_file_name,
      p$attention_character_action,
      p$break_key_action,
      p$end_of_information,
      p$input_block_size,
      p$input_editing_mode,
      p$input_output_mode,
      p$input_timeout,
      p$input_timeout_length,
      p$input_timeout_purge,
      p$partial_character_forwarding,
      p$prompt_file,
      p$prompt_string,
      p$store_backspace_character,
      p$store_nuls_dels,
      p$transparent_character_mode,
      p$transparent_forward_character,
      p$transparent_length_mode,
      p$transparent_message_length,
      p$transparent_protocol_mode,
      p$transparent_terminate_charact {TRANSPARENT_TERMINATE_CHARACTER} ,
      p$transparent_timeout_mode,
      p$status: 1 .. 23;


    status.normal := TRUE;

    attribute_limit := $INTEGER (ifc$max_connection_key);
    PUSH attributes_area: [[REP attribute_limit OF ift$connection_attribute]];
    RESET attributes_area;
    NEXT attributes: [1 .. attribute_limit] IN attributes_area;
    attribute_count := 0;

    lfn := clv$standard_files [clc$sf_job_output_file].path_handle_name;
    IF term_conn_type = c$term_conn_defaults THEN
      p$attention_character_action := 1;
      p$break_key_action := 2;
      p$end_of_information := 3;
      p$input_block_size := 4;
      p$input_editing_mode := 5;
      p$input_output_mode := 6;
      p$input_timeout := 7;
      p$input_timeout_length := 8;
      p$input_timeout_purge := 9;
      p$partial_character_forwarding := 10;
      p$prompt_file := 11;
      p$prompt_string := 12;
      p$store_backspace_character := 13;
      p$store_nuls_dels := 14;
      p$transparent_character_mode := 15;
      p$transparent_forward_character := 16;
      p$transparent_length_mode := 17;
      p$transparent_message_length := 18;
      p$transparent_protocol_mode := 19;
      p$transparent_terminate_charact := 20 {TRANSPARENT_TERMINATE_CHARACTER} ;
      p$transparent_timeout_mode := 21;
      p$status := 22;
    ELSE {c$term_conn_attributes}
      p$terminal_file_name := 1;
      p$attention_character_action := 2;
      p$break_key_action := 3;
      p$end_of_information := 4;
      p$input_block_size := 5;
      p$input_editing_mode := 6;
      p$input_output_mode := 7;
      p$input_timeout := 8;
      p$input_timeout_length := 9;
      p$input_timeout_purge := 10;
      p$partial_character_forwarding := 11;
      p$prompt_file := 12;
      p$prompt_string := 13;
      p$store_backspace_character := 14;
      p$store_nuls_dels := 15;
      p$transparent_character_mode := 16;
      p$transparent_forward_character := 17;
      p$transparent_length_mode := 18;
      p$transparent_message_length := 19;
      p$transparent_protocol_mode := 20;
      p$transparent_terminate_charact := 21 {TRANSPARENT_TERMINATE_CHARACTER} ;
      p$transparent_timeout_mode := 22;
      p$status := 23;
      IF pvt^ [p$terminal_file_name].specified THEN
        clp$convert_string_to_file (pvt^ [p$terminal_file_name].value^.file_value^, file, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        lfn := file.local_file_name;
      IFEND;
    IFEND;

    IF pvt^ [p$attention_character_action].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$attention_character_action;
      attributes^ [attribute_count].attention_character_action :=
            pvt^ [p$attention_character_action].value^.integer_value.value;
    IFEND;

    IF pvt^ [p$break_key_action].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$break_key_action;
      attributes^ [attribute_count].break_key_action := pvt^ [p$break_key_action].value^.integer_value.value;
    IFEND;

    IF pvt^ [p$end_of_information].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_of_information;
      attributes^ [attribute_count].end_of_information.size :=
            clp$trimmed_string_size (pvt^ [p$end_of_information].value^.string_value^);
      attributes^ [attribute_count].end_of_information.value :=
            pvt^ [p$end_of_information].value^.string_value^;
    IFEND;

    IF pvt^ [p$input_block_size].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_block_size;
      attributes^ [attribute_count].input_block_size := pvt^ [p$input_block_size].value^.integer_value.value;
    IFEND;

    IF pvt^ [p$input_editing_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_editing_mode;
      IF pvt^ [p$input_editing_mode].value^.keyword_value = 'NORMAL' THEN
        attributes^ [attribute_count].input_editing_mode := ifc$normal_edit;
      ELSEIF pvt^ [p$input_editing_mode].value^.keyword_value = 'TRANSPARENT' THEN
        attributes^ [attribute_count].input_editing_mode := ifc$trans_edit;
      IFEND;
    IFEND;

    IF pvt^ [p$input_output_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_output_mode;
      IF pvt^ [p$input_output_mode].value^.keyword_value = 'UNSOLICITED' THEN
        attributes^ [attribute_count].input_output_mode := ifc$unsolicited_output;
      ELSEIF pvt^ [p$input_output_mode].value^.keyword_value = 'SOLICITED' THEN
        attributes^ [attribute_count].input_output_mode := ifc$solicited;
      ELSEIF pvt^ [p$input_output_mode].value^.keyword_value = 'FULL_DUPLEX' THEN
        attributes^ [attribute_count].input_output_mode := ifc$full_duplex;
      IFEND;
    IFEND;

    IF pvt^ [p$input_timeout].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_timeout;
      attributes^ [attribute_count].input_timeout := pvt^ [p$input_timeout].value^.boolean_value.value;
    IFEND;

    IF pvt^ [p$input_timeout_length].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_timeout_length;
      attributes^ [attribute_count].input_timeout_length := pvt^ [p$input_timeout_length].value^.
            integer_value.value;
    IFEND;

    IF pvt^ [p$input_timeout_purge].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_timeout_purge;
      attributes^ [attribute_count].input_timeout_purge :=
            pvt^ [p$input_timeout_purge].value^.boolean_value.value;
    IFEND;

    IF pvt^ [p$partial_character_forwarding].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$partial_char_forwarding;
      attributes^ [attribute_count].partial_character_forwarding :=
            pvt^ [p$partial_character_forwarding].value^.boolean_value.value;
    IFEND;

    IF pvt^ [p$prompt_file].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$prompt_file;
      clp$convert_string_to_file (pvt^ [p$prompt_file].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      attributes^ [attribute_count].prompt_file := file.local_file_name;
    IFEND;

    IF pvt^ [p$prompt_string].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$prompt_string;
      attributes^ [attribute_count].prompt_string.size := STRLENGTH (pvt^ [p$prompt_string].value^.
            string_value^);
      attributes^ [attribute_count].prompt_string.value := pvt^ [p$prompt_string].value^.string_value^;
    IFEND;

    IF pvt^ [p$store_backspace_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$store_backspace_character;
      attributes^ [attribute_count].store_backspace_character :=
            pvt^ [p$store_backspace_character].value^.boolean_value.value;
    IFEND;

    IF pvt^ [p$store_nuls_dels].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$store_nuls_dels;
      attributes^ [attribute_count].store_nuls_dels := pvt^ [p$store_nuls_dels].value^.boolean_value.value;
    IFEND;

    IF pvt^ [p$transparent_character_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_character_mode;
      IF pvt^ [p$transparent_character_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$no_trans_char;
      ELSEIF pvt^ [p$transparent_character_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$trans_char_terminate;
      ELSEIF pvt^ [p$transparent_character_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$trans_char_forward;
      ELSEIF pvt^ [p$transparent_character_mode].value^.keyword_value = 'FORWARD_TERMINATE' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$trans_char_fwd_terminate;
      IFEND;
    IFEND;

    IF pvt^ [p$transparent_forward_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_forward_character;
      node := pvt^ [p$transparent_forward_character].value;
      i := 0;
      WHILE node <> NIL DO
        i := i + 1;
        attributes^ [attribute_count].trans_forward_character.value (i, 1) :=
              node^.element_value^.string_value^ (1, 1);
        node := node^.link;
      WHILEND;
      attributes^ [attribute_count].trans_forward_character.size := i;
    IFEND;

    IF pvt^ [p$transparent_length_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_length_mode;
      IF pvt^ [p$transparent_length_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$no_trans_len;
      ELSEIF pvt^ [p$transparent_length_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$trans_len_terminate;
      ELSEIF pvt^ [p$transparent_length_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$trans_len_forward;
      ELSEIF pvt^ [p$transparent_length_mode].value^.keyword_value = 'FORWARD_EXACT' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$trans_len_forward_exact;
      IFEND;
    IFEND;

    IF pvt^ [p$transparent_message_length].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_message_length;
      attributes^ [attribute_count].trans_message_length :=
            pvt^ [p$transparent_message_length].value^.integer_value.value;
    IFEND;

    IF pvt^ [p$transparent_terminate_charact].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_terminate_character;
      node := pvt^ [p$transparent_terminate_charact].value;
      i := 0;
      WHILE node <> NIL DO
        i := i + 1;
        attributes^ [attribute_count].trans_terminate_character.value (i, 1) :=
              node^.element_value^.string_value^ (1, 1);
        node := node^.link;
      WHILEND;
      attributes^ [attribute_count].trans_terminate_character.size := i;
    IFEND;

    IF pvt^ [p$transparent_timeout_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_timeout_mode;
      IF pvt^ [p$transparent_timeout_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_timeout_mode := ifc$no_trans_timeout;
      ELSEIF pvt^ [p$transparent_timeout_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_timeout_mode := ifc$trans_timeout_terminate;
      ELSEIF pvt^ [p$transparent_timeout_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_timeout_mode := ifc$trans_timeout_forward;
      IFEND;
    IFEND;

    IF pvt^ [p$transparent_protocol_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_protocol_mode;
      IF pvt^ [p$transparent_protocol_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_protocol_mode := ifc$no_trans_protocol;
      ELSEIF pvt^ [p$transparent_protocol_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_protocol_mode := ifc$trans_protocol_terminate;
      ELSEIF pvt^ [p$transparent_protocol_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_protocol_mode := ifc$trans_protocol_forward;
      IFEND;
    IFEND;

    IF attribute_count = 0 THEN
      RETURN;
    IFEND;

    RESET attributes_area;
    NEXT attributes: [1 .. attribute_count] IN attributes_area;
    IF term_conn_type = c$term_conn_attributes THEN
      ifp$change_term_conn_attributes (lfn, attributes^, status);
    ELSE {change_default}
      ifp$change_term_conn_defaults (lfn, attributes^, status);
    IFEND;

  PROCEND change_term_conn;
?? TITLE := 'display_attributes', EJECT ??

  PROCEDURE display_attributes
    (    display_name: ost$name_reference;
         subtitle_file: ^fst$file_reference;
         attributes_value: ^clt$data_value;
         output_file: fst$file_reference;
     VAR work_area {input, output} : ^clt$work_area;
     VAR status: ost$status);

*copy clv$display_variables

    VAR
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      ignore_status: ^ost$status,
      representation: ^clt$data_representation;

?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;


      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;
*copy clp$new_page_procedure
*copy clp$put_path_reference_subtitle
?? TITLE := 'put_subtitle', EJECT ??

    PROCEDURE [INLINE] put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);


      IF subtitle_file = NIL THEN
        clp$put_display (display_control, 'TERMINAL', clc$trim, status);
      ELSE
        clp$put_path_reference_subtitle (subtitle_file^, 'FILE ', status);
      IFEND;

    PROCEND put_subtitle;
?? OLDTITLE, EJECT ??

    status.normal := TRUE;

    display_control := clv$nil_display_control;
    #SPOIL (display_control);
    osp$establish_block_exit_hndlr (^abort_handler);

    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);
    clp$open_display_reference (output_file, ^clp$new_page_procedure, fsc$list, default_ring_attributes,
          display_control, status);
    IF NOT status.normal THEN
      osp$disestablish_cond_handler;
      RETURN
    IFEND;
    clv$titles_built := FALSE;
    clv$subtitles_built := FALSE;
    clv$command_name := display_name;

    IF display_control.page_width < clc$narrow_page_width THEN
      clv$page_width := clc$narrow_page_width;
    ELSEIF display_control.page_width > clc$wide_page_width THEN
      clv$page_width := clc$wide_page_width;
    ELSE
      clv$page_width := display_control.page_width;
    IFEND;

    clp$convert_data_to_string (attributes_value, clc$labeled_elem_representation, display_control.page_width,
          work_area, representation, status);
    IF status.normal THEN
      clp$put_data_representation (display_control, representation, status);
    IFEND;

    IF status.normal THEN
      clp$close_display (display_control, status);
    ELSE
      PUSH ignore_status;
      clp$close_display (display_control, ignore_status^);
    IFEND;

    osp$disestablish_cond_handler;

  PROCEND display_attributes;
?? TITLE := 'get_connection_attribute_key', EJECT ??

  PROCEDURE get_connection_attribute_key
    (    name: clt$keyword;
     VAR key: ift$connection_attribute_keys);

    VAR
      temp: integer,
      low_index: 1 .. max_connection_attributes + 1,
      high_index: 0 .. max_connection_attributes,
      current_index: 1 .. max_connection_attributes;


    low_index := 1;
    high_index := max_connection_attributes;

    REPEAT
      temp := low_index + high_index;
      current_index := temp DIV 2;
      IF name = connection_attribute_table [current_index].name THEN

        key := connection_attribute_table [current_index].key;
        RETURN;

      ELSEIF name > connection_attribute_table [current_index].name THEN
        low_index := current_index + 1;
      ELSE
        high_index := current_index - 1;
      IFEND;
    UNTIL low_index > high_index;

    key := UPPERVALUE (key);

  PROCEND get_connection_attribute_key;
?? TITLE := 'get_terminal_attribute_key', EJECT ??

  PROCEDURE get_terminal_attribute_key
    (    name: clt$keyword;
     VAR key: ift$terminal_attribute_keys);

    VAR
      temp: integer,
      low_index: 1 .. max_terminal_attributes + 1,
      high_index: 0 .. max_terminal_attributes,
      current_index: 1 .. max_terminal_attributes;


    low_index := 1;
    high_index := max_terminal_attributes;

    REPEAT
      temp := low_index + high_index;
      current_index := temp DIV 2;
      IF name = terminal_attribute_table [current_index].name THEN

        key := terminal_attribute_table [current_index].key;
        RETURN;

      ELSEIF name > terminal_attribute_table [current_index].name THEN
        low_index := current_index + 1;
      ELSE
        high_index := current_index - 1;
      IFEND;
    UNTIL low_index > high_index;

    key := UPPERVALUE (key);

  PROCEND get_terminal_attribute_key;
?? TITLE := 'ifp$$connection_attributes', EJECT ??

  PROCEDURE [XDCL] ifp$$connection_attributes
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$cona) $connection_attributes (
{   terminal_file_name: file = $required
{   attributes: any of
{       key
{         all
{       keyend
{       list of key
{         (attention_character_action, aca)
{         (break_key_action, bka)
{         (end_of_information, eoi)
{         (input_block_size, ibs)
{         (input_editing_mode, iem)
{         (input_output_mode, iom)
{         (input_timeout, it)
{         (input_timeout_length, itl)
{         (input_timeout_purge, itp)
{         (partial_character_forwarding, pcf)
{         (prompt_file, pf)
{         (prompt_string, ps)
{         (store_backspace_character, sbc)
{         (store_nuls_dels, snd)
{         (transparent_character_mode, tcm)
{         (transparent_forward_character, tfc)
{         (transparent_length_mode, tlm)
{         (transparent_message_length, tml)
{         (transparent_protocol_mode, tpm)
{         (transparent_terminate_character, ttc)
{         (transparent_timeout_mode, ttm)
{       keyend
{     anyend = all
{   )

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 2] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 42] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
    recend := [
    [1,
    [90, 3, 2, 11, 59, 35, 422],
    clc$function, 2, 2, 1, 0, 0, 0, 0, 'OSM$$TERCA'], [
    ['ATTRIBUTES                     ',clc$nominal_entry, 2],
    ['TERMINAL_FILE_NAME             ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1641,
  clc$optional_default_parameter, 0, 3]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    1577, [[1, 0, clc$list_type], [1561, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [42], [
        ['ACA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['ATTENTION_CHARACTER_ACTION     ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['BKA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['BREAK_KEY_ACTION               ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['END_OF_INFORMATION             ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['EOI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['IBS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['IEM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['INPUT_BLOCK_SIZE               ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['INPUT_EDITING_MODE             ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['INPUT_OUTPUT_MODE              ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['INPUT_TIMEOUT                  ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['INPUT_TIMEOUT_LENGTH           ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['INPUT_TIMEOUT_PURGE            ', clc$nominal_entry, clc$normal_usage_entry, 9],
        ['IOM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['IT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
        ['ITL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
        ['ITP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
        ['PARTIAL_CHARACTER_FORWARDING   ', clc$nominal_entry, clc$normal_usage_entry, 10],
        ['PCF                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
        ['PF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
        ['PROMPT_FILE                    ', clc$nominal_entry, clc$normal_usage_entry, 11],
        ['PROMPT_STRING                  ', clc$nominal_entry, clc$normal_usage_entry, 12],
        ['PS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
        ['SBC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
        ['SND                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
        ['STORE_BACKSPACE_CHARACTER      ', clc$nominal_entry, clc$normal_usage_entry, 13],
        ['STORE_NULS_DELS                ', clc$nominal_entry, clc$normal_usage_entry, 14],
        ['TCM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
        ['TFC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
        ['TLM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
        ['TML                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
        ['TPM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_CHARACTER_MODE     ', clc$nominal_entry, clc$normal_usage_entry, 15],
        ['TRANSPARENT_FORWARD_CHARACTER  ', clc$nominal_entry, clc$normal_usage_entry, 16],
        ['TRANSPARENT_LENGTH_MODE        ', clc$nominal_entry, clc$normal_usage_entry, 17],
        ['TRANSPARENT_MESSAGE_LENGTH     ', clc$nominal_entry, clc$normal_usage_entry, 18],
        ['TRANSPARENT_PROTOCOL_MODE      ', clc$nominal_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_TERMINATE_CHARACTER', clc$nominal_entry, clc$normal_usage_entry, 20],
        ['TRANSPARENT_TIMEOUT_MODE       ', clc$nominal_entry, clc$normal_usage_entry, 21],
        ['TTC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
        ['TTM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21]]
        ]
      ]
    ,
    'all']];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$terminal_file_name = 1,
      p$attributes = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    make_term_conn_attr_record (FALSE, pvt [p$terminal_file_name].value^.file_value, pvt [p$attributes],
          work_area, result, status);

  PROCEND ifp$$connection_attributes;
?? TITLE := 'ifp$$term_conn_defaults', EJECT ??

  PROCEDURE [XDCL] ifp$$term_conn_defaults
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$tercd) $term_conn_defaults (
{   attributes: any of
{       key
{         all
{       keyend
{       list of key
{         (attention_character_action, aca)
{         (break_key_action, bka)
{         (end_of_information, eoi)
{         (input_block_size, ibs)
{         (input_editing_mode, iem)
{         (input_output_mode, iom)
{         (input_timeout, it)
{         (input_timeout_length, itl)
{         (input_timeout_purge, itp)
{         (partial_character_forwarding, pcf)
{         (prompt_file, pf)
{         (prompt_string, ps)
{         (store_backspace_character, sbc)
{         (store_nuls_dels, snd)
{         (transparent_character_mode, tcm)
{         (transparent_forward_character, tfc)
{         (transparent_length_mode, tlm)
{         (transparent_message_length, tml)
{         (transparent_protocol_mode, tpm)
{         (transparent_terminate_character, ttc)
{         (transparent_timeout_mode, ttm)
{       keyend
{     anyend = all
{   )

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 42] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
    recend := [
    [1,
    [90, 3, 2, 12, 2, 40, 387],
    clc$function, 1, 1, 0, 0, 0, 0, 0, 'OSM$$TERCD'], [
    ['ATTRIBUTES                     ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1641,
  clc$optional_default_parameter, 0, 3]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    1577, [[1, 0, clc$list_type], [1561, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [42], [
        ['ACA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['ATTENTION_CHARACTER_ACTION     ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['BKA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['BREAK_KEY_ACTION               ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['END_OF_INFORMATION             ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['EOI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['IBS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['IEM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['INPUT_BLOCK_SIZE               ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['INPUT_EDITING_MODE             ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['INPUT_OUTPUT_MODE              ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['INPUT_TIMEOUT                  ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['INPUT_TIMEOUT_LENGTH           ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['INPUT_TIMEOUT_PURGE            ', clc$nominal_entry, clc$normal_usage_entry, 9],
        ['IOM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['IT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
        ['ITL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
        ['ITP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
        ['PARTIAL_CHARACTER_FORWARDING   ', clc$nominal_entry, clc$normal_usage_entry, 10],
        ['PCF                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
        ['PF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
        ['PROMPT_FILE                    ', clc$nominal_entry, clc$normal_usage_entry, 11],
        ['PROMPT_STRING                  ', clc$nominal_entry, clc$normal_usage_entry, 12],
        ['PS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
        ['SBC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
        ['SND                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
        ['STORE_BACKSPACE_CHARACTER      ', clc$nominal_entry, clc$normal_usage_entry, 13],
        ['STORE_NULS_DELS                ', clc$nominal_entry, clc$normal_usage_entry, 14],
        ['TCM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
        ['TFC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
        ['TLM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
        ['TML                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
        ['TPM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_CHARACTER_MODE     ', clc$nominal_entry, clc$normal_usage_entry, 15],
        ['TRANSPARENT_FORWARD_CHARACTER  ', clc$nominal_entry, clc$normal_usage_entry, 16],
        ['TRANSPARENT_LENGTH_MODE        ', clc$nominal_entry, clc$normal_usage_entry, 17],
        ['TRANSPARENT_MESSAGE_LENGTH     ', clc$nominal_entry, clc$normal_usage_entry, 18],
        ['TRANSPARENT_PROTOCOL_MODE      ', clc$nominal_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_TERMINATE_CHARACTER', clc$nominal_entry, clc$normal_usage_entry, 20],
        ['TRANSPARENT_TIMEOUT_MODE       ', clc$nominal_entry, clc$normal_usage_entry, 21],
        ['TTC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
        ['TTM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21]]
        ]
      ]
    ,
    'all']];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$attributes = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    make_term_conn_attr_record (FALSE, NIL, pvt [p$attributes], work_area, result, status);

  PROCEND ifp$$term_conn_defaults;
?? TITLE := 'ifp$$terminal_attributes', EJECT ??

  PROCEDURE [XDCL] ifp$$terminal_attributes
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$tera) $terminal_attributes (
{   attributes: any of
{       key
{         all
{       keyend
{       list of key
{         (attention_character, ac)
{         (backspace_character, bc)
{         (begin_line_character, blc)
{         (cancel_line_character, clc)
{         (carriage_return_delay, crd)
{         (carriage_return_sequence, crs)
{         (character_flow_control, cfc)
{         (code_set, cs)
{         (connect_view, cv)
{         (control_code_replacement, ccr)
{         (echoplex, e)
{         (end_line_character, elc)
{         (end_line_positioning, elp)
{         (end_output_sequence, eos)
{         (end_page_action, epa)
{         (end_partial_character, epc)
{         (end_partial_positioning, epp)
{         (fold_line, fl)
{         (form_feed_delay, ffd)
{         (form_feed_sequence, ffs)
{         (function_key_class, fkc)
{         (hold_page, hp)
{         (hold_page_over, hpo)
{         (line_feed_delay, lfd)
{         (line_feed_sequence, lfs)
{         (network, n)
{         (network_command_character, ncc)
{         (page_length, pl)
{         (page_width, pw)
{         (parity, p)
{         (pause_break_character, pbc)
{         (status_action, sa)
{         (terminal_class, tc)
{         (terminal_model, trm, tm)
{         (terminal_name, tn)
{         (terminate_break_character, tbc)
{       keyend
{     anyend = all
{   )

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 73] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
    recend := [
    [1,
    [90, 10, 26, 14, 21, 16, 459],
    clc$function, 1, 1, 0, 0, 0, 0, 0, 'OSM$$TERA'], [
    ['ATTRIBUTES                     ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 2788,
  clc$optional_default_parameter, 0, 3]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    2724, [[1, 0, clc$list_type], [2708, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [73], [
        ['AC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['ATTENTION_CHARACTER            ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['BACKSPACE_CHARACTER            ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['BC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['BEGIN_LINE_CHARACTER           ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['BLC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['CANCEL_LINE_CHARACTER          ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['CARRIAGE_RETURN_DELAY          ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['CARRIAGE_RETURN_SEQUENCE       ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['CCR                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
        ['CFC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
        ['CHARACTER_FLOW_CONTROL         ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['CLC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['CODE_SET                       ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['CONNECT_VIEW                   ', clc$nominal_entry, clc$normal_usage_entry, 9],
        ['CONTROL_CODE_REPLACEMENT       ', clc$nominal_entry, clc$normal_usage_entry, 10],
        ['CRD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['CRS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['CS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
        ['CV                             ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
        ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
        ['ECHOPLEX                       ', clc$nominal_entry, clc$normal_usage_entry, 11],
        ['ELC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
        ['ELP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
        ['END_LINE_CHARACTER             ', clc$nominal_entry, clc$normal_usage_entry, 12],
        ['END_LINE_POSITIONING           ', clc$nominal_entry, clc$normal_usage_entry, 13],
        ['END_OUTPUT_SEQUENCE            ', clc$nominal_entry, clc$normal_usage_entry, 14],
        ['END_PAGE_ACTION                ', clc$nominal_entry, clc$normal_usage_entry, 15],
        ['END_PARTIAL_CHARACTER          ', clc$nominal_entry, clc$normal_usage_entry, 16],
        ['END_PARTIAL_POSITIONING        ', clc$nominal_entry, clc$normal_usage_entry, 17],
        ['EOS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
        ['EPA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
        ['EPC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
        ['EPP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
        ['FFD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
        ['FFS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
        ['FKC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21],
        ['FL                             ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
        ['FOLD_LINE                      ', clc$nominal_entry, clc$normal_usage_entry, 18],
        ['FORM_FEED_DELAY                ', clc$nominal_entry, clc$normal_usage_entry, 19],
        ['FORM_FEED_SEQUENCE             ', clc$nominal_entry, clc$normal_usage_entry, 20],
        ['FUNCTION_KEY_CLASS             ', clc$nominal_entry, clc$normal_usage_entry, 21],
        ['HOLD_PAGE                      ', clc$nominal_entry, clc$normal_usage_entry, 22],
        ['HOLD_PAGE_OVER                 ', clc$nominal_entry, clc$normal_usage_entry, 23],
        ['HP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 22],
        ['HPO                            ', clc$abbreviation_entry, clc$normal_usage_entry, 23],
        ['LFD                            ', clc$abbreviation_entry, clc$normal_usage_entry, 24],
        ['LFS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 25],
        ['LINE_FEED_DELAY                ', clc$nominal_entry, clc$normal_usage_entry, 24],
        ['LINE_FEED_SEQUENCE             ', clc$nominal_entry, clc$normal_usage_entry, 25],
        ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 26],
        ['NCC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 27],
        ['NETWORK                        ', clc$nominal_entry, clc$normal_usage_entry, 26],
        ['NETWORK_COMMAND_CHARACTER      ', clc$nominal_entry, clc$normal_usage_entry, 27],
        ['P                              ', clc$abbreviation_entry, clc$normal_usage_entry, 30],
        ['PAGE_LENGTH                    ', clc$nominal_entry, clc$normal_usage_entry, 28],
        ['PAGE_WIDTH                     ', clc$nominal_entry, clc$normal_usage_entry, 29],
        ['PARITY                         ', clc$nominal_entry, clc$normal_usage_entry, 30],
        ['PAUSE_BREAK_CHARACTER          ', clc$nominal_entry, clc$normal_usage_entry, 31],
        ['PBC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 31],
        ['PL                             ', clc$abbreviation_entry, clc$normal_usage_entry, 28],
        ['PW                             ', clc$abbreviation_entry, clc$normal_usage_entry, 29],
        ['SA                             ', clc$abbreviation_entry, clc$normal_usage_entry, 32],
        ['STATUS_ACTION                  ', clc$nominal_entry, clc$normal_usage_entry, 32],
        ['TBC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 36],
        ['TC                             ', clc$abbreviation_entry, clc$normal_usage_entry, 33],
        ['TERMINAL_CLASS                 ', clc$nominal_entry, clc$normal_usage_entry, 33],
        ['TERMINAL_MODEL                 ', clc$nominal_entry, clc$normal_usage_entry, 34],
        ['TERMINAL_NAME                  ', clc$nominal_entry, clc$normal_usage_entry, 35],
        ['TERMINATE_BREAK_CHARACTER      ', clc$nominal_entry, clc$normal_usage_entry, 36],
        ['TM                             ', clc$abbreviation_entry, clc$normal_usage_entry, 34],
        ['TN                             ', clc$abbreviation_entry, clc$normal_usage_entry, 35],
        ['TRM                            ', clc$alias_entry, clc$normal_usage_entry, 34]]
        ]
      ]
    ,
    'all']];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$attributes = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    make_term_attr_record (FALSE, pvt [p$attributes], work_area, result, status);

  PROCEND ifp$$terminal_attributes;
?? TITLE := 'ifp$$terminal_model', EJECT ??

  PROCEDURE [XDCL] ifp$$terminal_model
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$terminal_model) $terminal_model (
{   terminal_file_name: file = $local.command
{   )

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        default_value: string (14),
      recend,
    recend := [
    [1,
    [90, 3, 1, 17, 33, 35, 6],
    clc$function, 1, 1, 0, 0, 0, 0, 0, 'OSM$$TERMINAL_MODEL'], [
    ['TERMINAL_FILE_NAME             ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 14]],
{ PARAMETER 1
    [[1, 0, clc$file_type],
    '$local.command']];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$terminal_file_name = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;

    VAR
      attribute: array [1 .. 1] of ift$terminal_attribute;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    attribute [1].key := ifc$terminal_model;
    ifp$get_terminal_attributes (pvt [p$terminal_file_name].value^.file_value^, attribute, status);
    IF status.normal THEN
      clp$make_string_value (attribute [1].terminal_model.value (1, attribute [1].terminal_model.size),
            work_area, result);
    ELSE
      status.normal := TRUE;
      clp$make_sized_string_value (0, work_area, result);
    IFEND;

  PROCEND ifp$$terminal_model;
?? TITLE := 'ifp$_attach_job', EJECT ??

  PROCEDURE [XDCL] ifp$_attach_job
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$attj) attach_job, attj (
{   job_name, jn: name = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 1, 17, 47, 5, 817],
    clc$command, 3, 2, 0, 0, 0, 0, 2, 'OSM$ATTJ'], [
    ['JN                             ',clc$abbreviation_entry, 1],
    ['JOB_NAME                       ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$job_name = 1,
      p$status = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

    VAR
      job_name: jmt$user_supplied_name;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pvt [p$job_name].specified THEN
      job_name := pvt [p$job_name].value^.name_value;
    ELSE
      job_name := osc$null_name;
    IFEND;

    jmp$attach_timesharing_job (job_name, status);

  PROCEND ifp$_attach_job;
?? TITLE := 'ifp$_change_connection_attribut', EJECT ??

  PROCEDURE [XDCL] ifp$_change_connection_attribut
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$chatca) change_connection_attributes, change_connection_attribute, ..
{ change_term_conn_attributes, change_term_conn_attribute, chatca, chaca (
{   terminal_file_name, tfn: file = $required
{   attention_character_action, aca: (BY_NAME) integer 0..9 = $optional
{   break_key_action, bka: (BY_NAME) integer 0..9 = $optional
{   end_of_information, eoi: (BY_NAME) string 0..31 = $optional
{   input_block_size, ibs: (BY_NAME) integer 80..2000 = $optional
{   input_editing_mode, iem: (BY_NAME) key
{       (normal, n)
{       (transparent, t)
{     keyend = $optional
{   input_output_mode, iom: (BY_NAME) key
{       (unsolicited, u)
{       (solicited, s)
{       (full_duplex, fullduplex, f)
{     keyend = $optional
{   input_timeout, it: (BY_NAME) boolean = $optional
{   input_timeout_length, itl: (BY_NAME) integer 0..1048575 = $optional
{   input_timeout_purge, itp: (BY_NAME) boolean = $optional
{   partial_character_forwarding, pcf: (BY_NAME) boolean = $optional
{   prompt_file, pf: (BY_NAME) file = $optional
{   prompt_string, ps: (BY_NAME) string 0..31 = $optional
{   store_backspace_character, sbc: (BY_NAME) boolean = $optional
{   store_nuls_dels, snd: (BY_NAME) boolean = $optional
{   transparent_character_mode, tcm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{       (forward_terminate, ft)
{     keyend = $optional
{   transparent_forward_character, tfc: (BY_NAME) list 1..4 of string 1 = $optional
{   transparent_length_mode, tlm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{       (forward_exact, fe)
{     keyend = $optional
{   transparent_message_length, tml: (BY_NAME) integer 1..32767 = $optional
{   transparent_protocol_mode, tpm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{     keyend = $optional
{   transparent_terminate_character, ttc: (BY_NAME) list 1..4 of string 1 = $optional
{   transparent_timeout_mode, ttm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{     keyend = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 45] of clt$pdt_parameter_name,
      parameters: array [1 .. 23] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 7] of clt$keyword_specification,
      recend,
      type8: record
        header: clt$type_specification_header,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type10: record
        header: clt$type_specification_header,
      recend,
      type11: record
        header: clt$type_specification_header,
      recend,
      type12: record
        header: clt$type_specification_header,
      recend,
      type13: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type14: record
        header: clt$type_specification_header,
      recend,
      type15: record
        header: clt$type_specification_header,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type17: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type18: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type19: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type20: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type21: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type22: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type23: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 2, 17, 40, 49, 122],
    clc$command, 45, 23, 1, 0, 0, 0, 23, 'OSM$CHATCA'], [
    ['ACA                            ',clc$abbreviation_entry, 2],
    ['ATTENTION_CHARACTER_ACTION     ',clc$nominal_entry, 2],
    ['BKA                            ',clc$abbreviation_entry, 3],
    ['BREAK_KEY_ACTION               ',clc$nominal_entry, 3],
    ['END_OF_INFORMATION             ',clc$nominal_entry, 4],
    ['EOI                            ',clc$abbreviation_entry, 4],
    ['IBS                            ',clc$abbreviation_entry, 5],
    ['IEM                            ',clc$abbreviation_entry, 6],
    ['INPUT_BLOCK_SIZE               ',clc$nominal_entry, 5],
    ['INPUT_EDITING_MODE             ',clc$nominal_entry, 6],
    ['INPUT_OUTPUT_MODE              ',clc$nominal_entry, 7],
    ['INPUT_TIMEOUT                  ',clc$nominal_entry, 8],
    ['INPUT_TIMEOUT_LENGTH           ',clc$nominal_entry, 9],
    ['INPUT_TIMEOUT_PURGE            ',clc$nominal_entry, 10],
    ['IOM                            ',clc$abbreviation_entry, 7],
    ['IT                             ',clc$abbreviation_entry, 8],
    ['ITL                            ',clc$abbreviation_entry, 9],
    ['ITP                            ',clc$abbreviation_entry, 10],
    ['PARTIAL_CHARACTER_FORWARDING   ',clc$nominal_entry, 11],
    ['PCF                            ',clc$abbreviation_entry, 11],
    ['PF                             ',clc$abbreviation_entry, 12],
    ['PROMPT_FILE                    ',clc$nominal_entry, 12],
    ['PROMPT_STRING                  ',clc$nominal_entry, 13],
    ['PS                             ',clc$abbreviation_entry, 13],
    ['SBC                            ',clc$abbreviation_entry, 14],
    ['SND                            ',clc$abbreviation_entry, 15],
    ['STATUS                         ',clc$nominal_entry, 23],
    ['STORE_BACKSPACE_CHARACTER      ',clc$nominal_entry, 14],
    ['STORE_NULS_DELS                ',clc$nominal_entry, 15],
    ['TCM                            ',clc$abbreviation_entry, 16],
    ['TERMINAL_FILE_NAME             ',clc$nominal_entry, 1],
    ['TFC                            ',clc$abbreviation_entry, 17],
    ['TFN                            ',clc$abbreviation_entry, 1],
    ['TLM                            ',clc$abbreviation_entry, 18],
    ['TML                            ',clc$abbreviation_entry, 19],
    ['TPM                            ',clc$abbreviation_entry, 20],
    ['TRANSPARENT_CHARACTER_MODE     ',clc$nominal_entry, 16],
    ['TRANSPARENT_FORWARD_CHARACTER  ',clc$nominal_entry, 17],
    ['TRANSPARENT_LENGTH_MODE        ',clc$nominal_entry, 18],
    ['TRANSPARENT_MESSAGE_LENGTH     ',clc$nominal_entry, 19],
    ['TRANSPARENT_PROTOCOL_MODE      ',clc$nominal_entry, 20],
    ['TRANSPARENT_TERMINATE_CHARACTER',clc$nominal_entry, 21],
    ['TRANSPARENT_TIMEOUT_MODE       ',clc$nominal_entry, 22],
    ['TTC                            ',clc$abbreviation_entry, 21],
    ['TTM                            ',clc$abbreviation_entry, 22]],
    [
{ PARAMETER 1
    [31, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 4
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 5
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 6
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 266,
  clc$optional_parameter, 0, 0],
{ PARAMETER 8
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 9
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 10
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 11
    [19, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 12
    [22, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 13
    [23, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 14
    [28, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 15
    [29, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 16
    [37, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 17
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 24, clc$optional_parameter,
  0, 0],
{ PARAMETER 18
    [39, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 19
    [40, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 20
    [41, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 21
    [42, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 24, clc$optional_parameter,
  0, 0],
{ PARAMETER 22
    [43, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 23
    [27, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [0, 9, 10]],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [0, 9, 10]],
{ PARAMETER 4
    [[1, 0, clc$string_type], [0, 31, FALSE]],
{ PARAMETER 5
    [[1, 0, clc$integer_type], [80, 2000, 10]],
{ PARAMETER 6
    [[1, 0, clc$keyword_type], [4], [
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NORMAL                         ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TRANSPARENT                    ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 7
    [[1, 0, clc$keyword_type], [7], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FULLDUPLEX                     ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['FULL_DUPLEX                    ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['SOLICITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['UNSOLICITED                    ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 8
    [[1, 0, clc$boolean_type]],
{ PARAMETER 9
    [[1, 0, clc$integer_type], [0, 1048575, 10]],
{ PARAMETER 10
    [[1, 0, clc$boolean_type]],
{ PARAMETER 11
    [[1, 0, clc$boolean_type]],
{ PARAMETER 12
    [[1, 0, clc$file_type]],
{ PARAMETER 13
    [[1, 0, clc$string_type], [0, 31, FALSE]],
{ PARAMETER 14
    [[1, 0, clc$boolean_type]],
{ PARAMETER 15
    [[1, 0, clc$boolean_type]],
{ PARAMETER 16
    [[1, 0, clc$keyword_type], [8], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['FORWARD_TERMINATE              ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['FT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 17
    [[1, 0, clc$list_type], [8, 1, 4, 0, FALSE, FALSE],
      [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 18
    [[1, 0, clc$keyword_type], [8], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FE                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['FORWARD_EXACT                  ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 19
    [[1, 0, clc$integer_type], [1, 32767, 10]],
{ PARAMETER 20
    [[1, 0, clc$keyword_type], [6], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 21
    [[1, 0, clc$list_type], [8, 1, 4, 0, FALSE, FALSE],
      [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 22
    [[1, 0, clc$keyword_type], [6], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 23
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$terminal_file_name = 1,
      p$attention_character_action = 2,
      p$break_key_action = 3,
      p$end_of_information = 4,
      p$input_block_size = 5,
      p$input_editing_mode = 6,
      p$input_output_mode = 7,
      p$input_timeout = 8,
      p$input_timeout_length = 9,
      p$input_timeout_purge = 10,
      p$partial_character_forwarding = 11,
      p$prompt_file = 12,
      p$prompt_string = 13,
      p$store_backspace_character = 14,
      p$store_nuls_dels = 15,
      p$transparent_character_mode = 16,
      p$transparent_forward_character = 17,
      p$transparent_length_mode = 18,
      p$transparent_message_length = 19,
      p$transparent_protocol_mode = 20,
      p$transparent_terminate_charact = 21 {TRANSPARENT_TERMINATE_CHARACTER} ,
      p$transparent_timeout_mode = 22,
      p$status = 23;

    VAR
      pvt: array [1 .. 23] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    change_term_conn (^pvt, c$term_conn_attributes, status);

  PROCEND ifp$_change_connection_attribut;
?? TITLE := 'ifp$_change_term_conn_defaults', EJECT ??

  PROCEDURE [XDCL] ifp$_change_term_conn_defaults
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$chatcd) change_term_conn_defaults, change_term_conn_default, chatcd (
{   attention_character_action, aca: integer 0..9 = $optional
{   break_key_action, bka: integer 0..9 = $optional
{   end_of_information, eoi: string 0..31 = $optional
{   input_block_size, ibs: integer 80..2000 = $optional
{   input_editing_mode, iem: key
{       (normal, n)
{       (transparent, t)
{     keyend = $optional
{   input_output_mode, iom: key
{       (unsolicited, u)
{       (solicited, s)
{       (full_duplex, fullduplex, f)
{     keyend = $optional
{   input_timeout, it: boolean = $optional
{   input_timeout_length, itl: integer 0..1048575 = $optional
{   input_timeout_purge, itp: boolean = $optional
{   partial_character_forwarding, pcf: boolean = $optional
{   prompt_file, pf: file = $optional
{   prompt_string, ps: string 0..31 = $optional
{   store_backspace_character, sbc: boolean = $optional
{   store_nuls_dels, snd: boolean = $optional
{   transparent_character_mode, tcm: key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{       (forward_terminate, ft)
{     keyend = $optional
{   transparent_forward_character, tfc: list 1..4 of string 1 = $optional
{   transparent_length_mode, tlm: key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{       (forward_exact, fe)
{     keyend = $optional
{   transparent_message_length, tml: integer 1..32767 = $optional
{   transparent_protocol_mode, tpm: key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{     keyend = $optional
{   transparent_terminate_character, ttc: list 1..4 of string 1 = $optional
{   transparent_timeout_mode, ttm: key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{     keyend = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 43] of clt$pdt_parameter_name,
      parameters: array [1 .. 22] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 7] of clt$keyword_specification,
      recend,
      type7: record
        header: clt$type_specification_header,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type9: record
        header: clt$type_specification_header,
      recend,
      type10: record
        header: clt$type_specification_header,
      recend,
      type11: record
        header: clt$type_specification_header,
      recend,
      type12: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type13: record
        header: clt$type_specification_header,
      recend,
      type14: record
        header: clt$type_specification_header,
      recend,
      type15: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type17: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type18: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type19: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type20: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type21: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type22: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 2, 12, 43, 47, 931],
    clc$command, 43, 22, 0, 0, 0, 0, 22, 'OSM$CHATCD'], [
    ['ACA                            ',clc$abbreviation_entry, 1],
    ['ATTENTION_CHARACTER_ACTION     ',clc$nominal_entry, 1],
    ['BKA                            ',clc$abbreviation_entry, 2],
    ['BREAK_KEY_ACTION               ',clc$nominal_entry, 2],
    ['END_OF_INFORMATION             ',clc$nominal_entry, 3],
    ['EOI                            ',clc$abbreviation_entry, 3],
    ['IBS                            ',clc$abbreviation_entry, 4],
    ['IEM                            ',clc$abbreviation_entry, 5],
    ['INPUT_BLOCK_SIZE               ',clc$nominal_entry, 4],
    ['INPUT_EDITING_MODE             ',clc$nominal_entry, 5],
    ['INPUT_OUTPUT_MODE              ',clc$nominal_entry, 6],
    ['INPUT_TIMEOUT                  ',clc$nominal_entry, 7],
    ['INPUT_TIMEOUT_LENGTH           ',clc$nominal_entry, 8],
    ['INPUT_TIMEOUT_PURGE            ',clc$nominal_entry, 9],
    ['IOM                            ',clc$abbreviation_entry, 6],
    ['IT                             ',clc$abbreviation_entry, 7],
    ['ITL                            ',clc$abbreviation_entry, 8],
    ['ITP                            ',clc$abbreviation_entry, 9],
    ['PARTIAL_CHARACTER_FORWARDING   ',clc$nominal_entry, 10],
    ['PCF                            ',clc$abbreviation_entry, 10],
    ['PF                             ',clc$abbreviation_entry, 11],
    ['PROMPT_FILE                    ',clc$nominal_entry, 11],
    ['PROMPT_STRING                  ',clc$nominal_entry, 12],
    ['PS                             ',clc$abbreviation_entry, 12],
    ['SBC                            ',clc$abbreviation_entry, 13],
    ['SND                            ',clc$abbreviation_entry, 14],
    ['STATUS                         ',clc$nominal_entry, 22],
    ['STORE_BACKSPACE_CHARACTER      ',clc$nominal_entry, 13],
    ['STORE_NULS_DELS                ',clc$nominal_entry, 14],
    ['TCM                            ',clc$abbreviation_entry, 15],
    ['TFC                            ',clc$abbreviation_entry, 16],
    ['TLM                            ',clc$abbreviation_entry, 17],
    ['TML                            ',clc$abbreviation_entry, 18],
    ['TPM                            ',clc$abbreviation_entry, 19],
    ['TRANSPARENT_CHARACTER_MODE     ',clc$nominal_entry, 15],
    ['TRANSPARENT_FORWARD_CHARACTER  ',clc$nominal_entry, 16],
    ['TRANSPARENT_LENGTH_MODE        ',clc$nominal_entry, 17],
    ['TRANSPARENT_MESSAGE_LENGTH     ',clc$nominal_entry, 18],
    ['TRANSPARENT_PROTOCOL_MODE      ',clc$nominal_entry, 19],
    ['TRANSPARENT_TERMINATE_CHARACTER',clc$nominal_entry, 20],
    ['TRANSPARENT_TIMEOUT_MODE       ',clc$nominal_entry, 21],
    ['TTC                            ',clc$abbreviation_entry, 20],
    ['TTM                            ',clc$abbreviation_entry, 21]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 2
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 4
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 5
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 6
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 266,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 8
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 9
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 10
    [19, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 11
    [22, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 12
    [23, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 13
    [28, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 14
    [29, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 15
    [35, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 16
    [36, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 24, clc$optional_parameter,
  0, 0],
{ PARAMETER 17
    [37, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 18
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 19
    [39, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 20
    [40, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 24, clc$optional_parameter,
  0, 0],
{ PARAMETER 21
    [41, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 22
    [27, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$integer_type], [0, 9, 10]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [0, 9, 10]],
{ PARAMETER 3
    [[1, 0, clc$string_type], [0, 31, FALSE]],
{ PARAMETER 4
    [[1, 0, clc$integer_type], [80, 2000, 10]],
{ PARAMETER 5
    [[1, 0, clc$keyword_type], [4], [
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NORMAL                         ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TRANSPARENT                    ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 6
    [[1, 0, clc$keyword_type], [7], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FULLDUPLEX                     ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['FULL_DUPLEX                    ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['SOLICITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['UNSOLICITED                    ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 7
    [[1, 0, clc$boolean_type]],
{ PARAMETER 8
    [[1, 0, clc$integer_type], [0, 1048575, 10]],
{ PARAMETER 9
    [[1, 0, clc$boolean_type]],
{ PARAMETER 10
    [[1, 0, clc$boolean_type]],
{ PARAMETER 11
    [[1, 0, clc$file_type]],
{ PARAMETER 12
    [[1, 0, clc$string_type], [0, 31, FALSE]],
{ PARAMETER 13
    [[1, 0, clc$boolean_type]],
{ PARAMETER 14
    [[1, 0, clc$boolean_type]],
{ PARAMETER 15
    [[1, 0, clc$keyword_type], [8], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['FORWARD_TERMINATE              ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['FT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 16
    [[1, 0, clc$list_type], [8, 1, 4, 0, FALSE, FALSE],
      [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 17
    [[1, 0, clc$keyword_type], [8], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FE                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['FORWARD_EXACT                  ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 18
    [[1, 0, clc$integer_type], [1, 32767, 10]],
{ PARAMETER 19
    [[1, 0, clc$keyword_type], [6], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 20
    [[1, 0, clc$list_type], [8, 1, 4, 0, FALSE, FALSE],
      [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 21
    [[1, 0, clc$keyword_type], [6], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 22
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$attention_character_action = 1,
      p$break_key_action = 2,
      p$end_of_information = 3,
      p$input_block_size = 4,
      p$input_editing_mode = 5,
      p$input_output_mode = 6,
      p$input_timeout = 7,
      p$input_timeout_length = 8,
      p$input_timeout_purge = 9,
      p$partial_character_forwarding = 10,
      p$prompt_file = 11,
      p$prompt_string = 12,
      p$store_backspace_character = 13,
      p$store_nuls_dels = 14,
      p$transparent_character_mode = 15,
      p$transparent_forward_character = 16,
      p$transparent_length_mode = 17,
      p$transparent_message_length = 18,
      p$transparent_protocol_mode = 19,
      p$transparent_terminate_charact = 20 {TRANSPARENT_TERMINATE_CHARACTER} ,
      p$transparent_timeout_mode = 21,
      p$status = 22;

    VAR
      pvt: array [1 .. 22] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    change_term_conn (^pvt, c$term_conn_defaults, status);

  PROCEND ifp$_change_term_conn_defaults;
?? TITLE := 'ifp$_change_terminal_attributes', EJECT ??

  PROCEDURE [XDCL] ifp$_change_terminal_attributes
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$setta) change_terminal_attributes, change_terminal_attribute, set_terminal_attributes, ..
{ set_terminal_attribute, setta, chata (
{   attention_character, ac: (BY_NAME) string 1 = $optional
{   backspace_character, bc: (BY_NAME) string 1 = $optional
{   begin_line_character, blc: (BY_NAME) string 1 = $optional
{   cancel_line_character, clc: (BY_NAME) string 1 = $optional
{   carriage_return_delay, crd: (BY_NAME) integer 0..1000 = $optional
{   carriage_return_sequence, crs: (BY_NAME) string 0..2 = $optional
{   character_flow_control, cfc: (BY_NAME) boolean = $optional
{   code_set, cs: (BY_NAME) any of
{       key
{         ascii, bpapl, tpapl, ascii48, ascii64, ascii95, ascii128, ascii256, ebcdic
{       keyend
{       name
{     anyend = $optional
{   control_code_replacement, ccr: (BY_NAME) any of
{       key
{         none
{       keyend
{       list 1..64 of record
{         original: range of string 1
{         substitute: string 1 = $optional
{       recend
{     anyend = $optional
{   echoplex, e: (BY_NAME) boolean = $optional
{   end_line_character, elc: (BY_NAME) string 1 = $optional
{   end_line_positioning, elp: (BY_NAME) key
{       none, crs, lfs, crslfs
{     keyend = $optional
{   end_output_sequence, eos: (BY_NAME) string 0..4 = $optional
{   end_page_action, epa: (BY_NAME) key
{       none, ffs
{     keyend = $optional
{   end_partial_character, epc: (BY_NAME) string 1 = $optional
{   end_partial_positioning, epp: (BY_NAME) key
{       none, crs, lfs, crslfs
{     keyend = $optional
{   fold_line, fl: (BY_NAME) boolean = $optional
{   form_feed_delay, ffd: (BY_NAME) integer 0..3000 = $optional
{   form_feed_sequence, ffs: (BY_NAME) string 0..7 = $optional
{   function_key_class, fkc: (BY_NAME) any of
{       key
{         none
{       keyend
{       name
{     anyend = $optional
{   hold_page, hp: (BY_NAME) boolean = $optional
{   hold_page_over, hpo: (BY_NAME) boolean = $optional
{   line_feed_delay, lfd: (BY_NAME) integer 0..1000 = $optional
{   line_feed_sequence, lfs: (BY_NAME) string 0..2 = $optional
{   network_command_character, ncc: (BY_NAME) string 1 = $optional
{   page_length, pl: (BY_NAME) integer 0..255 = $optional
{   page_width, pw: (BY_NAME) integer 0..255 = $optional
{   parity, p: (BY_NAME) key
{       even, none, odd, zero, mark
{     keyend = $optional
{   pause_break_character, pbc: (BY_NAME) string 1 = $optional
{   status_action, sa: (BY_NAME) key
{       (send, s)
{       (hold, h)
{       (discard, d)
{     keyend = $optional
{   terminal_class, tc: (BY_NAME) key
{       (cdc200ut, c200ut)
{       (cdc711, c711)
{       (cdc714_10, c714_20, cdc714_20, c714_10)
{       (cdc714_30, c714_40, cdc714_40, c714_30)
{       (cdc721, c721)
{       (cdc73x, c73x)
{       (cdc75x, cdc713, c713, c75x)
{       hasp_post, hasp_pre
{       (hp2000, h2000)
{       (ibm2740, i2740)
{       (ibm2741, i2741)
{       (ibm3270, i3270)
{       (ibm3780, i3780)
{       t4010, tty, tty40
{       (x364, vt100)
{     keyend = $optional
{   terminal_model, trm, tm: (BY_NAME) any of
{       key
{         none
{       keyend
{       name 1..25
{     anyend = $optional
{   terminate_break_character, tbc: (BY_NAME) string 1 = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 68] of clt$pdt_parameter_name,
      parameters: array [1 .. 34] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type7: record
        header: clt$type_specification_header,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 9] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$record_type_qualifier,
            field_spec_1: clt$field_specification,
            element_type_spec_1: record
              header: clt$type_specification_header,
              qualifier: clt$range_type_qualifier,
              element_type_spec: record
                header: clt$type_specification_header,
                qualifier: clt$string_type_qualifier,
              recend,
            recend,
            field_spec_2: clt$field_specification,
            element_type_spec_2: record
              header: clt$type_specification_header,
              qualifier: clt$string_type_qualifier,
            recend,
          recend,
        recend,
      recend,
      type10: record
        header: clt$type_specification_header,
      recend,
      type11: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type12: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type13: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type14: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 2] of clt$keyword_specification,
      recend,
      type15: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type17: record
        header: clt$type_specification_header,
      recend,
      type18: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type19: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type20: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
      recend,
      type21: record
        header: clt$type_specification_header,
      recend,
      type22: record
        header: clt$type_specification_header,
      recend,
      type23: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type24: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type25: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type26: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type27: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type28: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 5] of clt$keyword_specification,
      recend,
      type29: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type30: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type31: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 37] of clt$keyword_specification,
      recend,
      type32: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
      recend,
      type33: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type34: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 2, 17, 44, 24, 866],
    clc$command, 68, 34, 0, 0, 0, 0, 34, 'OSM$SETTA'], [
    ['AC                             ',clc$abbreviation_entry, 1],
    ['ATTENTION_CHARACTER            ',clc$nominal_entry, 1],
    ['BACKSPACE_CHARACTER            ',clc$nominal_entry, 2],
    ['BC                             ',clc$abbreviation_entry, 2],
    ['BEGIN_LINE_CHARACTER           ',clc$nominal_entry, 3],
    ['BLC                            ',clc$abbreviation_entry, 3],
    ['CANCEL_LINE_CHARACTER          ',clc$nominal_entry, 4],
    ['CARRIAGE_RETURN_DELAY          ',clc$nominal_entry, 5],
    ['CARRIAGE_RETURN_SEQUENCE       ',clc$nominal_entry, 6],
    ['CCR                            ',clc$abbreviation_entry, 9],
    ['CFC                            ',clc$abbreviation_entry, 7],
    ['CHARACTER_FLOW_CONTROL         ',clc$nominal_entry, 7],
    ['CLC                            ',clc$abbreviation_entry, 4],
    ['CODE_SET                       ',clc$nominal_entry, 8],
    ['CONTROL_CODE_REPLACEMENT       ',clc$nominal_entry, 9],
    ['CRD                            ',clc$abbreviation_entry, 5],
    ['CRS                            ',clc$abbreviation_entry, 6],
    ['CS                             ',clc$abbreviation_entry, 8],
    ['E                              ',clc$abbreviation_entry, 10],
    ['ECHOPLEX                       ',clc$nominal_entry, 10],
    ['ELC                            ',clc$abbreviation_entry, 11],
    ['ELP                            ',clc$abbreviation_entry, 12],
    ['END_LINE_CHARACTER             ',clc$nominal_entry, 11],
    ['END_LINE_POSITIONING           ',clc$nominal_entry, 12],
    ['END_OUTPUT_SEQUENCE            ',clc$nominal_entry, 13],
    ['END_PAGE_ACTION                ',clc$nominal_entry, 14],
    ['END_PARTIAL_CHARACTER          ',clc$nominal_entry, 15],
    ['END_PARTIAL_POSITIONING        ',clc$nominal_entry, 16],
    ['EOS                            ',clc$abbreviation_entry, 13],
    ['EPA                            ',clc$abbreviation_entry, 14],
    ['EPC                            ',clc$abbreviation_entry, 15],
    ['EPP                            ',clc$abbreviation_entry, 16],
    ['FFD                            ',clc$abbreviation_entry, 18],
    ['FFS                            ',clc$abbreviation_entry, 19],
    ['FKC                            ',clc$abbreviation_entry, 20],
    ['FL                             ',clc$abbreviation_entry, 17],
    ['FOLD_LINE                      ',clc$nominal_entry, 17],
    ['FORM_FEED_DELAY                ',clc$nominal_entry, 18],
    ['FORM_FEED_SEQUENCE             ',clc$nominal_entry, 19],
    ['FUNCTION_KEY_CLASS             ',clc$nominal_entry, 20],
    ['HOLD_PAGE                      ',clc$nominal_entry, 21],
    ['HOLD_PAGE_OVER                 ',clc$nominal_entry, 22],
    ['HP                             ',clc$abbreviation_entry, 21],
    ['HPO                            ',clc$abbreviation_entry, 22],
    ['LFD                            ',clc$abbreviation_entry, 23],
    ['LFS                            ',clc$abbreviation_entry, 24],
    ['LINE_FEED_DELAY                ',clc$nominal_entry, 23],
    ['LINE_FEED_SEQUENCE             ',clc$nominal_entry, 24],
    ['NCC                            ',clc$abbreviation_entry, 25],
    ['NETWORK_COMMAND_CHARACTER      ',clc$nominal_entry, 25],
    ['P                              ',clc$abbreviation_entry, 28],
    ['PAGE_LENGTH                    ',clc$nominal_entry, 26],
    ['PAGE_WIDTH                     ',clc$nominal_entry, 27],
    ['PARITY                         ',clc$nominal_entry, 28],
    ['PAUSE_BREAK_CHARACTER          ',clc$nominal_entry, 29],
    ['PBC                            ',clc$abbreviation_entry, 29],
    ['PL                             ',clc$abbreviation_entry, 26],
    ['PW                             ',clc$abbreviation_entry, 27],
    ['SA                             ',clc$abbreviation_entry, 30],
    ['STATUS                         ',clc$nominal_entry, 34],
    ['STATUS_ACTION                  ',clc$nominal_entry, 30],
    ['TBC                            ',clc$abbreviation_entry, 33],
    ['TC                             ',clc$abbreviation_entry, 31],
    ['TERMINAL_CLASS                 ',clc$nominal_entry, 31],
    ['TERMINAL_MODEL                 ',clc$nominal_entry, 32],
    ['TERMINATE_BREAK_CHARACTER      ',clc$nominal_entry, 33],
    ['TM                             ',clc$abbreviation_entry, 32],
    ['TRM                            ',clc$alias_entry, 32]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 4
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 5
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 6
    [9, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 7
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 8
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 365,
  clc$optional_parameter, 0, 0],
{ PARAMETER 9
    [15, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 182,
  clc$optional_parameter, 0, 0],
{ PARAMETER 10
    [20, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 11
    [23, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 12
    [24, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 13
    [25, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 14
    [26, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 81, clc$optional_parameter,
  0, 0],
{ PARAMETER 15
    [27, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 16
    [28, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 17
    [37, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 18
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 19
    [39, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 20
    [40, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69, clc$optional_parameter,
  0, 0],
{ PARAMETER 21
    [41, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 22
    [42, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 23
    [47, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 24
    [48, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 25
    [50, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 26
    [52, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 27
    [53, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 28
    [54, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 192,
  clc$optional_parameter, 0, 0],
{ PARAMETER 29
    [55, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 30
    [61, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 31
    [64, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1376,
  clc$optional_parameter, 0, 0],
{ PARAMETER 32
    [65, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69, clc$optional_parameter,
  0, 0],
{ PARAMETER 33
    [66, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 34
    [60, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 2
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 3
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 4
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 5
    [[1, 0, clc$integer_type], [0, 1000, 10]],
{ PARAMETER 6
    [[1, 0, clc$string_type], [0, 2, FALSE]],
{ PARAMETER 7
    [[1, 0, clc$boolean_type]],
{ PARAMETER 8
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    340, [[1, 0, clc$keyword_type], [9], [
      ['ASCII                          ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['ASCII128                       ', clc$nominal_entry, clc$normal_usage_entry, 7],
      ['ASCII256                       ', clc$nominal_entry, clc$normal_usage_entry, 8],
      ['ASCII48                        ', clc$nominal_entry, clc$normal_usage_entry, 4],
      ['ASCII64                        ', clc$nominal_entry, clc$normal_usage_entry, 5],
      ['ASCII95                        ', clc$nominal_entry, clc$normal_usage_entry, 6],
      ['BPAPL                          ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['EBCDIC                         ', clc$nominal_entry, clc$normal_usage_entry, 9],
      ['TPAPL                          ', clc$nominal_entry, clc$normal_usage_entry, 3]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 9
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    118, [[1, 0, clc$list_type], [102, 1, 64, 0, FALSE, FALSE],
        [[1, 0, clc$record_type], [2],
        ['ORIGINAL                       ', clc$required_field, 15], [[1, 0, clc$range_type], [8],
            [[1, 0, clc$string_type], [1, 1, FALSE]]
          ],
        ['SUBSTITUTE                     ', clc$optional_field, 8], [[1, 0, clc$string_type], [1, 1, FALSE]]
        ]
      ]
    ],
{ PARAMETER 10
    [[1, 0, clc$boolean_type]],
{ PARAMETER 11
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 12
    [[1, 0, clc$keyword_type], [4], [
    ['CRS                            ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['CRSLFS                         ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['LFS                            ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 13
    [[1, 0, clc$string_type], [0, 4, FALSE]],
{ PARAMETER 14
    [[1, 0, clc$keyword_type], [2], [
    ['FFS                            ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 15
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 16
    [[1, 0, clc$keyword_type], [4], [
    ['CRS                            ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['CRSLFS                         ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['LFS                            ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 17
    [[1, 0, clc$boolean_type]],
{ PARAMETER 18
    [[1, 0, clc$integer_type], [0, 3000, 10]],
{ PARAMETER 19
    [[1, 0, clc$string_type], [0, 7, FALSE]],
{ PARAMETER 20
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 21
    [[1, 0, clc$boolean_type]],
{ PARAMETER 22
    [[1, 0, clc$boolean_type]],
{ PARAMETER 23
    [[1, 0, clc$integer_type], [0, 1000, 10]],
{ PARAMETER 24
    [[1, 0, clc$string_type], [0, 2, FALSE]],
{ PARAMETER 25
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 26
    [[1, 0, clc$integer_type], [0, 255, 10]],
{ PARAMETER 27
    [[1, 0, clc$integer_type], [0, 255, 10]],
{ PARAMETER 28
    [[1, 0, clc$keyword_type], [5], [
    ['EVEN                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['MARK                           ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['ODD                            ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['ZERO                           ', clc$nominal_entry, clc$normal_usage_entry, 4]]
    ],
{ PARAMETER 29
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 30
    [[1, 0, clc$keyword_type], [6], [
    ['D                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['DISCARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['H                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['HOLD                           ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['SEND                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 31
    [[1, 0, clc$keyword_type], [37], [
    ['C200UT                         ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['C711                           ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['C713                           ', clc$alias_entry, clc$normal_usage_entry, 7],
    ['C714_10                        ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['C714_20                        ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['C714_30                        ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['C714_40                        ', clc$alias_entry, clc$normal_usage_entry, 4],
    ['C721                           ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['C73X                           ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
    ['C75X                           ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
    ['CDC200UT                       ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['CDC711                         ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['CDC713                         ', clc$alias_entry, clc$normal_usage_entry, 7],
    ['CDC714_10                      ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['CDC714_20                      ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['CDC714_30                      ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['CDC714_40                      ', clc$alias_entry, clc$normal_usage_entry, 4],
    ['CDC721                         ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['CDC73X                         ', clc$nominal_entry, clc$normal_usage_entry, 6],
    ['CDC75X                         ', clc$nominal_entry, clc$normal_usage_entry, 7],
    ['H2000                          ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
    ['HASP_POST                      ', clc$nominal_entry, clc$normal_usage_entry, 8],
    ['HASP_PRE                       ', clc$nominal_entry, clc$normal_usage_entry, 9],
    ['HP2000                         ', clc$nominal_entry, clc$normal_usage_entry, 10],
    ['I2740                          ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
    ['I2741                          ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
    ['I3270                          ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
    ['I3780                          ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
    ['IBM2740                        ', clc$nominal_entry, clc$normal_usage_entry, 11],
    ['IBM2741                        ', clc$nominal_entry, clc$normal_usage_entry, 12],
    ['IBM3270                        ', clc$nominal_entry, clc$normal_usage_entry, 13],
    ['IBM3780                        ', clc$nominal_entry, clc$normal_usage_entry, 14],
    ['T4010                          ', clc$nominal_entry, clc$normal_usage_entry, 15],
    ['TTY                            ', clc$nominal_entry, clc$normal_usage_entry, 16],
    ['TTY40                          ', clc$nominal_entry, clc$normal_usage_entry, 17],
    ['VT100                          ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
    ['X364                           ', clc$nominal_entry, clc$normal_usage_entry, 18]]
    ],
{ PARAMETER 32
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, 25]]
    ],
{ PARAMETER 33
    [[1, 0, clc$string_type], [1, 1, FALSE]],
{ PARAMETER 34
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$attention_character = 1,
      p$backspace_character = 2,
      p$begin_line_character = 3,
      p$cancel_line_character = 4,
      p$carriage_return_delay = 5,
      p$carriage_return_sequence = 6,
      p$character_flow_control = 7,
      p$code_set = 8,
      p$control_code_replacement = 9,
      p$echoplex = 10,
      p$end_line_character = 11,
      p$end_line_positioning = 12,
      p$end_output_sequence = 13,
      p$end_page_action = 14,
      p$end_partial_character = 15,
      p$end_partial_positioning = 16,
      p$fold_line = 17,
      p$form_feed_delay = 18,
      p$form_feed_sequence = 19,
      p$function_key_class = 20,
      p$hold_page = 21,
      p$hold_page_over = 22,
      p$line_feed_delay = 23,
      p$line_feed_sequence = 24,
      p$network_command_character = 25,
      p$page_length = 26,
      p$page_width = 27,
      p$parity = 28,
      p$pause_break_character = 29,
      p$status_action = 30,
      p$terminal_class = 31,
      p$terminal_model = 32,
      p$terminate_break_character = 33,
      p$status = 34;

    VAR
      pvt: array [1 .. 34] of clt$parameter_value;

    VAR
      attributes: ^ift$terminal_attributes,
      attributes_area: ^SEQ ( * ),
      attribute_count: integer,
      attribute_limit: integer,
      j: integer,
      node: ^clt$data_value,
      original_char: char;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    attribute_limit := $INTEGER (ifc$max_terminal_attribute_key);
    PUSH attributes_area: [[REP attribute_limit OF ift$terminal_attribute]];
    RESET attributes_area;
    NEXT attributes: [1 .. attribute_limit] IN attributes_area;
    attribute_count := 0;

    IF pvt [p$attention_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$attention_character;
      attributes^ [attribute_count].attention_character := pvt [p$attention_character].
            value^.string_value^ (1);
    IFEND;

    IF pvt [p$backspace_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$backspace_character;
      attributes^ [attribute_count].backspace_character := pvt [p$backspace_character].
            value^.string_value^ (1);
    IFEND;

    IF pvt [p$begin_line_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$begin_line_character;
      attributes^ [attribute_count].begin_line_character := pvt [p$begin_line_character].value^.
            string_value^ (1);
    IFEND;

    IF pvt [p$cancel_line_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$cancel_line_character;
      attributes^ [attribute_count].cancel_line_character := pvt [p$cancel_line_character].value^.
            string_value^ (1);
    IFEND;

    IF pvt [p$carriage_return_delay].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$carriage_return_delay;
      attributes^ [attribute_count].carriage_return_delay :=
            pvt [p$carriage_return_delay].value^.integer_value.value;
    IFEND;

    IF pvt [p$carriage_return_sequence].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$carriage_return_sequence;
      attributes^ [attribute_count].carriage_return_sequence.size :=
            clp$trimmed_string_size (pvt [p$carriage_return_sequence].value^.string_value^);
      attributes^ [attribute_count].carriage_return_sequence.value :=
            pvt [p$carriage_return_sequence].value^.string_value^;
    IFEND;

    IF pvt [p$character_flow_control].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$character_flow_control;
      attributes^ [attribute_count].character_flow_control :=
            pvt [p$character_flow_control].value^.boolean_value.value;
    IFEND;

    IF pvt [p$code_set].specified THEN
      attribute_count := attribute_count + 1;
      IF pvt [p$code_set].value^.kind = clc$keyword THEN
        IF pvt [p$code_set].value^.keyword_value = 'ASCII' THEN
          attributes^ [attribute_count].key := ifc$code_set;
          attributes^ [attribute_count].code_set := ifc$ascii_code_set;
        ELSEIF pvt [p$code_set].value^.keyword_value = 'BPAPL' THEN
          attributes^ [attribute_count].key := ifc$code_set;
          attributes^ [attribute_count].code_set := ifc$bpapl_code_set;
        ELSEIF pvt [p$code_set].value^.keyword_value = 'TPAPL' THEN
          attributes^ [attribute_count].key := ifc$code_set;
          attributes^ [attribute_count].code_set := ifc$tpapl_code_set;
        ELSE
          attributes^ [attribute_count].key := ifc$code_set_name;
          PUSH attributes^ [attribute_count].code_set_name;
          attributes^ [attribute_count].code_set_name^.size :=
                clp$trimmed_string_size (pvt [p$code_set].value^.keyword_value);
          attributes^ [attribute_count].code_set_name^.value := pvt [p$code_set].value^.keyword_value;
        IFEND;
      ELSE
        attributes^ [attribute_count].key := ifc$code_set_name;
        PUSH attributes^ [attribute_count].code_set_name;
        attributes^ [attribute_count].code_set_name^.size :=
              clp$trimmed_string_size (pvt [p$code_set].value^.name_value);
        attributes^ [attribute_count].code_set_name^.value := pvt [p$code_set].value^.name_value;
      IFEND;
    IFEND;

    IF pvt [p$control_code_replacement].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$control_code_replacement;
      PUSH attributes^ [attribute_count].control_code_replacement;
      attributes^ [attribute_count].control_code_replacement^.total_substitution_count := 0;
      IF pvt [p$control_code_replacement].value^.kind <> clc$keyword THEN

{ The Control_Code_Replacement attribute is not 'NONE'.

        j := 0;
        node := pvt [p$control_code_replacement].value;
        WHILE node <> NIL DO

{ Create each Control_Code_Replacement record by grouping each value in the range of
{ original control codes with its substitute control code.

          FOR original_char := node^.element_value^.field_values^ [1].value^.low_value^.string_value^ (1)
                TO node^.element_value^.field_values^ [1].value^.high_value^.string_value^ (1) DO
            j := j + 1;
            attributes^ [attribute_count].control_code_replacement^.value [j].original_control_code :=
                  original_char;
            IF (node^.element_value^.field_values^ [2].value = NIL) THEN
              attributes^ [attribute_count].control_code_replacement^.value [j].substitute_control_code :=
                    original_char;
            ELSE
              attributes^ [attribute_count].control_code_replacement^.value [j].substitute_control_code :=
                    node^.element_value^.field_values^ [2].value^.string_value^ (1);
            IFEND;
          FOREND;

{ Increment the total number of Control_Code_Replacement records.

          attributes^ [attribute_count].control_code_replacement^.total_substitution_count :=
                attributes^ [attribute_count].control_code_replacement^.total_substitution_count +
                ($INTEGER (node^.element_value^.field_values^ [1].value^.high_value^.string_value^ (1)) -
                $INTEGER (node^.element_value^.field_values^ [1].value^.low_value^.string_value^ (1)) + 1);

          node := node^.link;
        WHILEND;
      IFEND;
    IFEND;

    IF pvt [p$echoplex].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$echoplex;
      attributes^ [attribute_count].echoplex := pvt [p$echoplex].value^.boolean_value.value;
    IFEND;

    IF pvt [p$end_line_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_line_character;
      attributes^ [attribute_count].end_line_character := pvt [p$end_line_character].value^.string_value^ (1);
    IFEND;

    IF pvt [p$end_line_positioning].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_line_positioning;
      IF pvt [p$end_line_positioning].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].end_line_positioning := ifc$elp_none;
      ELSEIF pvt [p$end_line_positioning].value^.keyword_value = 'CRS' THEN
        attributes^ [attribute_count].end_line_positioning := ifc$elp_crs;
      ELSEIF pvt [p$end_line_positioning].value^.keyword_value = 'LFS' THEN
        attributes^ [attribute_count].end_line_positioning := ifc$elp_lfs;
      ELSEIF pvt [p$end_line_positioning].value^.keyword_value = 'CRSLFS' THEN
        attributes^ [attribute_count].end_line_positioning := ifc$elp_crslfs;
      IFEND;
    IFEND;

    IF pvt [p$end_output_sequence].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_output_sequence;
      attributes^ [attribute_count].end_output_sequence.size :=
            clp$trimmed_string_size (pvt [p$end_output_sequence].value^.string_value^);
      attributes^ [attribute_count].end_output_sequence.value :=
            pvt [p$end_output_sequence].value^.string_value^;
    IFEND;

    IF pvt [p$end_page_action].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_page_action;
      IF pvt [p$end_page_action].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].end_page_action := ifc$no_epa;
      ELSEIF pvt [p$end_page_action].value^.keyword_value = 'FFS' THEN
        attributes^ [attribute_count].end_page_action := ifc$epa_ffs;
      IFEND;
    IFEND;

    IF pvt [p$end_partial_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_partial_character;
      attributes^ [attribute_count].end_partial_character := pvt [p$end_partial_character].value^.
            string_value^ (1);
    IFEND;

    IF pvt [p$end_partial_positioning].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_partial_positioning;
      IF pvt [p$end_partial_positioning].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].end_partial_positioning := ifc$no_epp;
      ELSEIF pvt [p$end_partial_positioning].value^.keyword_value = 'CRS' THEN
        attributes^ [attribute_count].end_partial_positioning := ifc$epp_crs;
      ELSEIF pvt [p$end_partial_positioning].value^.keyword_value = 'LFS' THEN
        attributes^ [attribute_count].end_partial_positioning := ifc$epp_lfs;
      ELSEIF pvt [p$end_partial_positioning].value^.keyword_value = 'CRSLFS' THEN
        attributes^ [attribute_count].end_partial_positioning := ifc$epp_crslfs;
      IFEND;
    IFEND;

    IF pvt [p$fold_line].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$fold_line;
      attributes^ [attribute_count].fold_line := pvt [p$fold_line].value^.boolean_value.value;
    IFEND;

    IF pvt [p$form_feed_delay].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$form_feed_delay;
      attributes^ [attribute_count].form_feed_delay := pvt [p$form_feed_delay].value^.integer_value.value;
    IFEND;

    IF pvt [p$form_feed_sequence].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$form_feed_sequence;
      attributes^ [attribute_count].form_feed_sequence.size :=
            clp$trimmed_string_size (pvt [p$form_feed_sequence].value^.string_value^);
      attributes^ [attribute_count].form_feed_sequence.value := pvt [p$form_feed_sequence].value^.
            string_value^;
    IFEND;

    IF pvt [p$function_key_class].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$function_key_class;
      PUSH attributes^ [attribute_count].function_key_class;
      IF pvt [p$function_key_class].value^.kind = clc$keyword THEN
        attributes^ [attribute_count].function_key_class^.size := 1;
        attributes^ [attribute_count].function_key_class^.value := '';
      ELSE
        attributes^ [attribute_count].function_key_class^.size :=
              clp$trimmed_string_size (pvt [p$function_key_class].value^.name_value);
        attributes^ [attribute_count].function_key_class^.value :=
              pvt [p$function_key_class].value^.name_value;
      IFEND;
    IFEND;

    IF pvt [p$hold_page].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$hold_page;
      attributes^ [attribute_count].hold_page := pvt [p$hold_page].value^.boolean_value.value;
    IFEND;

    IF pvt [p$hold_page_over].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$hold_page_over;
      attributes^ [attribute_count].hold_page_over := pvt [p$hold_page_over].value^.boolean_value.value;
    IFEND;

    IF pvt [p$line_feed_delay].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$line_feed_delay;
      attributes^ [attribute_count].line_feed_delay := pvt [p$line_feed_delay].value^.integer_value.value;
    IFEND;

    IF pvt [p$line_feed_sequence].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$line_feed_sequence;
      attributes^ [attribute_count].line_feed_sequence.size :=
            STRLENGTH (pvt [p$line_feed_sequence].value^.string_value^);
      attributes^ [attribute_count].line_feed_sequence.value := pvt [p$line_feed_sequence].value^.
            string_value^;
    IFEND;

    IF pvt [p$network_command_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$network_command_character;
      attributes^ [attribute_count].network_command_character :=
            pvt [p$network_command_character].value^.string_value^ (1);
    IFEND;

    IF pvt [p$page_length].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$page_length;
      attributes^ [attribute_count].page_length := pvt [p$page_length].value^.integer_value.value;
    IFEND;

    IF pvt [p$page_width].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$page_width;
      attributes^ [attribute_count].page_width := pvt [p$page_width].value^.integer_value.value;
    IFEND;

    IF pvt [p$parity].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$parity;
      IF pvt [p$parity].value^.keyword_value = 'EVEN' THEN
        attributes^ [attribute_count].parity := ifc$even_parity;
      ELSEIF pvt [p$parity].value^.keyword_value = 'ODD' THEN
        attributes^ [attribute_count].parity := ifc$odd_parity;
      ELSEIF pvt [p$parity].value^.keyword_value = 'ZERO' THEN
        attributes^ [attribute_count].parity := ifc$zero_parity;
      ELSEIF pvt [p$parity].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].parity := ifc$no_parity;
      ELSEIF pvt [p$parity].value^.keyword_value = 'MARK' THEN
        attributes^ [attribute_count].parity := ifc$mark_parity;
      IFEND;
    IFEND;

    IF pvt [p$pause_break_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$pause_break_character;
      attributes^ [attribute_count].pause_break_character := pvt [p$pause_break_character].value^.
            string_value^ (1);
    IFEND;

    IF pvt [p$status_action].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$status_action;
      IF (pvt [p$status_action].value^.keyword_value = 'SEND') OR
            (pvt [p$status_action].value^.keyword_value = 'S') THEN
        attributes^ [attribute_count].status_action := ifc$send_status;
      ELSEIF (pvt [p$status_action].value^.keyword_value = 'HOLD') OR
            (pvt [p$status_action].value^.keyword_value = 'H') THEN
        attributes^ [attribute_count].status_action := ifc$hold_status;
      ELSEIF (pvt [p$status_action].value^.keyword_value = 'DISCARD') OR
            (pvt [p$status_action].value^.keyword_value = 'D') THEN
        attributes^ [attribute_count].status_action := ifc$discard_status;
      IFEND;
    IFEND;

    IF pvt [p$terminal_class].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$terminal_class;

      IF pvt [p$terminal_class].value^.keyword_value = 'CDC200UT' {C200UT} THEN
        attributes^ [attribute_count].terminal_class := ifc$c200ut_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'CDC711' {C711} THEN
        attributes^ [attribute_count].terminal_class := ifc$c711_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'CDC714_10' {CDC714_20 C714_20 C714_10} THEN
        attributes^ [attribute_count].terminal_class := ifc$c714_10_20_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'CDC714_30' {CDC714_40 C714_40 C714_30} THEN
        attributes^ [attribute_count].terminal_class := ifc$c714_30_40;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'CDC721' {C721} THEN
        attributes^ [attribute_count].terminal_class := ifc$c721_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'CDC73X' {C73X} THEN
        attributes^ [attribute_count].terminal_class := ifc$c73x_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'CDC75X' {CDC713 C713 C75X} THEN
        attributes^ [attribute_count].terminal_class := ifc$c75x_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'HASP_POST' THEN
        attributes^ [attribute_count].terminal_class := ifc$hasp_post_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'HASP_PRE' THEN
        attributes^ [attribute_count].terminal_class := ifc$hasp_pre_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'HP2000' {H2000} THEN
        attributes^ [attribute_count].terminal_class := ifc$h2000_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'IBM2740' {I2740} THEN
        attributes^ [attribute_count].terminal_class := ifc$i2740_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'IBM2741' {I2741} THEN
        attributes^ [attribute_count].terminal_class := ifc$i2741_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'IBM3270' {I3270} THEN
        attributes^ [attribute_count].terminal_class := ifc$i3270_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'IBM3780' {I3780} THEN
        attributes^ [attribute_count].terminal_class := ifc$i3780_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'T4010' THEN
        attributes^ [attribute_count].terminal_class := ifc$t4010_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'TTY' THEN
        attributes^ [attribute_count].terminal_class := ifc$tty_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'TTY40' THEN
        attributes^ [attribute_count].terminal_class := ifc$tty40_class;
      ELSEIF pvt [p$terminal_class].value^.keyword_value = 'X364' {VT100} THEN
        attributes^ [attribute_count].terminal_class := ifc$x364_class;
      IFEND;
    IFEND;

    IF pvt [p$terminal_model].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$terminal_model;
      IF pvt [p$terminal_model].value^.kind = clc$keyword THEN
        attributes^ [attribute_count].terminal_model.size := 1;
        attributes^ [attribute_count].terminal_model.value := '';
      ELSE
        attributes^ [attribute_count].terminal_model.size :=
              clp$trimmed_string_size (pvt [p$terminal_model].value^.name_value);
        attributes^ [attribute_count].terminal_model.value := pvt [p$terminal_model].value^.name_value;
      IFEND;
    IFEND;

    IF pvt [p$terminate_break_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$terminate_break_character;
      attributes^ [attribute_count].terminate_break_character :=
            pvt [p$terminate_break_character].value^.string_value^ (1);
    IFEND;

    IF attribute_count = 0 THEN
      RETURN;
    IFEND;

    RESET attributes_area;
    NEXT attributes: [1 .. attribute_count] IN attributes_area;
    ifp$change_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name, attributes^,
          status);

  PROCEND ifp$_change_terminal_attributes;

?? TITLE := '[XDCL] ifp$_create_telnet_connection', EJECT ??

{ PURPOSE:
{   This is the Command Processor for the CREATE_TELNET_CONNECTION command.
{
{   Once this command is executed, the user's current host connection is
{   suspended by CDCNET and all subsequent user input is sent (by CDCNET)
{   on the Telnet connection.  When the user clears his Telnet connection,
{   CDCNET puts the user back into the original host connection.
{
{   The Telnet connection is actually a CDCNET connection to a User Telnet
{   Gateway.  The name of the gateway to use is configured in each CDCNET
{   DI via the DEFINE_TELNET_SERVICE_NAME command.

  PROCEDURE [XDCL] ifp$_create_telnet_connection
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);


{ PROCEDURE (osm$cretc) create_telnet_connection, telnet, cretc (
{   host, h: any of
{       string 1..63
{       application
{     anyend = $required
{   connection_data_1, cd1: (CHECK, SECURE) string 1..127 = $optional
{   connection_data_2, cd2: (CHECK, SECURE) string 1..127 = $optional
{   connection_data_3, cd3: (CHECK, SECURE) string 1..127 = $optional
{   end_discard_prompt, edp: string 1..16 = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 11] of clt$pdt_parameter_name,
      parameters: array [1 .. 6] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$application_type_qualifier,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type6: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [92, 2, 11, 13, 30, 41, 877],
    clc$command, 11, 6, 1, 0, 0, 0, 6, 'OSM$CRETC'], [
    ['CD1                            ',clc$abbreviation_entry, 2],
    ['CD2                            ',clc$abbreviation_entry, 3],
    ['CD3                            ',clc$abbreviation_entry, 4],
    ['CONNECTION_DATA_1              ',clc$nominal_entry, 2],
    ['CONNECTION_DATA_2              ',clc$nominal_entry, 3],
    ['CONNECTION_DATA_3              ',clc$nominal_entry, 4],
    ['EDP                            ',clc$abbreviation_entry, 5],
    ['END_DISCARD_PROMPT             ',clc$nominal_entry, 5],
    ['H                              ',clc$abbreviation_entry, 1],
    ['HOST                           ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 6]],
    [
{ PARAMETER 1
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 32, clc$required_parameter,
  0, 0],
{ PARAMETER 2
    [4, clc$normal_usage_entry, clc$secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$extended_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$extended_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 4
    [6, clc$normal_usage_entry, clc$secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$extended_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 5
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 6
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$application_type, clc$string_type],
    FALSE, 2],
    8, [[1, 0, clc$string_type], [1, 63, FALSE]],
    4, [[1, 0, clc$application_type], [FALSE]]
    ],
{ PARAMETER 2
    [[1, 0, clc$string_type], [1, 127, FALSE]],
{ PARAMETER 3
    [[1, 0, clc$string_type], [1, 127, FALSE]],
{ PARAMETER 4
    [[1, 0, clc$string_type], [1, 127, FALSE]],
{ PARAMETER 5
    [[1, 0, clc$string_type], [1, 16, FALSE]],
{ PARAMETER 6
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$host = 1,
      p$connection_data_1 = 2,
      p$connection_data_2 = 3,
      p$connection_data_3 = 4,
      p$end_discard_prompt = 5,
      p$status = 6;

    VAR
      pvt: array [1 .. 6] of clt$parameter_value;

?? NEWTITLE := 'check_procedure', EJECT ??

    PROCEDURE check_procedure
      (    parameter_value_table: ^clt$parameter_value_table;
           which_parameter: clt$which_parameter;
       VAR status: ost$status);

      VAR
        first: boolean,
        parameter_length: 0 .. clc$max_string_size,
        second: boolean,
        third: boolean;

      status.normal := TRUE;

      IF NOT which_parameter.specific THEN
        IF (parameter_value_table^ [p$host].value^.kind = clc$application) THEN
          parameter_length := STRLENGTH (parameter_value_table^ [p$host].value^.application_value^);
          IF (parameter_length > max_host_parameter_length) OR (parameter_length < 1) THEN
            osp$set_status_condition (ife$invalid_host_parameter_size, status);
            RETURN;
          IFEND;
        IFEND;

        first := parameter_value_table^ [p$connection_data_1].specified;
        second := parameter_value_table^ [p$connection_data_2].specified;
        third := parameter_value_table^ [p$connection_data_3].specified;

        IF second AND (NOT first) THEN
          osp$set_status_abnormal ('IF', ife$connection_data_dependent, 'CONNECTION_DATA_2', status);
          osp$append_status_parameter (osc$status_parameter_delimiter, 'CONNECTION_DATA_1', status);
          RETURN;
        IFEND;

        IF third AND ((NOT second) OR (NOT first)) THEN
          osp$set_status_abnormal ('IF', ife$connection_data_dependent, 'CONNECTION_DATA_3', status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
                'CONNECTION_DATA_1 and CONNECTION_DATA_2', status);
          RETURN;
        IFEND;
      IFEND;

    PROCEND check_procedure;
?? OLDTITLE, EJECT ??

    VAR
      connection_data_1: ^SEQ ( * ),
      connection_data_2: ^SEQ ( * ),
      connection_data_3: ^SEQ ( * ),
      end_discard_prompt: ^SEQ ( * ),
      host_name: ^string ( * ),
      telnet_connection_limit: integer,
      telnet_service_name: [STATIC] ost$name := 'TELNET';

    status.normal := TRUE;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), ^check_procedure, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pvt [p$host].value^.kind = clc$string THEN
      host_name := pvt [p$host].value^.string_value;
    ELSEIF pvt [p$host].value^.kind = clc$application THEN
      host_name := pvt [p$host].value^.application_value;
    IFEND;

    IF pvt [p$connection_data_1].specified THEN
      connection_data_1 := #SEQ (pvt [p$connection_data_1].value^.string_value^);
    ELSE
      connection_data_1 := NIL;
    IFEND;

    IF pvt [p$connection_data_2].specified THEN
      connection_data_2 := #SEQ (pvt [p$connection_data_2].value^.string_value^);
    ELSE
      connection_data_2 := NIL;
    IFEND;

    IF pvt [p$connection_data_3].specified THEN
      connection_data_3 := #SEQ (pvt [p$connection_data_3].value^.string_value^);
    ELSE
      connection_data_3 := NIL;
    IFEND;

    IF pvt [p$end_discard_prompt].specified THEN
      end_discard_prompt := #SEQ (pvt [p$end_discard_prompt].value^.string_value^);
    ELSE
      end_discard_prompt := NIL;
    IFEND;

    ifp$get_telnet_connection_limit (telnet_connection_limit);

    ifp$vtp_create_cdcnet_connect (telnet_service_name, #SEQ (host_name^), connection_data_1,
          connection_data_2, connection_data_3, end_discard_prompt, telnet_connection_limit, status);

  PROCEND ifp$_create_telnet_connection;
?? TITLE := '[XDCL, #GATE] ifp$vtp_create_cdcnet_connect', EJECT ??
*copy ifh$vtp_create_cdcnet_connect

  PROCEDURE [XDCL, #GATE] ifp$vtp_create_cdcnet_connect
    (    service_name: ost$name;
         service_data: ^SEQ ( * );
         connection_data_1: ^SEQ ( * );
         connection_data_2: ^SEQ ( * );
         connection_data_3: ^SEQ ( * );
         end_discard_prompt: ^SEQ ( * );
         timeout_interval_in_ms: 0 .. 0ffffffff(16);
     VAR status: ost$status);

    VAR
      file_id: amt$file_identifier,
      job_attribute_p: ^jmt$job_attribute_results,
      parameter_length: 0 .. clc$max_string_size;


    status.normal := TRUE;

    clp$put_job_command_response (' ', status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_system_file_id (clc$job_command_response, file_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$flush (file_id, osc$wait, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    PUSH job_attribute_p: [1 .. 1];
    job_attribute_p^ [1].key := jmc$origin_application_name;
    jmp$get_job_attributes (job_attribute_p, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF job_attribute_p^ [1].origin_application_name <> osc$timesharing THEN
      osp$set_status_condition (ife$must_be_timesharing, status);
      RETURN;
    IFEND;

    IF service_data <> NIL THEN
      parameter_length := #SIZE (service_data^);
      IF (parameter_length > max_host_parameter_length) OR (parameter_length < 1) THEN
        osp$set_status_condition (ife$invalid_host_parameter_size, status);
        RETURN;
      IFEND;
    IFEND;

    IF (connection_data_2 <> NIL) AND (connection_data_1 = NIL) THEN
      osp$set_status_abnormal ('IF', ife$connection_data_dependent, 'CONNECTION_DATA_2', status);
      osp$append_status_parameter (osc$status_parameter_delimiter, 'CONNECTION_DATA_1', status);
      RETURN;
    IFEND;

    IF (connection_data_3 <> NIL) AND ((connection_data_1 = NIL) OR (connection_data_2 = NIL)) THEN
      osp$set_status_abnormal ('IF', ife$connection_data_dependent, 'CONNECTION_DATA_3', status);
      osp$append_status_parameter (osc$status_parameter_delimiter,
            'CONNECTION_DATA_1 and CONNECTION_DATA_2', status);
      RETURN;
    IFEND;

    iip$vtp_create_cdcnet_connect (service_name, service_data, connection_data_1, connection_data_2,
          connection_data_3, end_discard_prompt, timeout_interval_in_ms, status);

  PROCEND ifp$vtp_create_cdcnet_connect;

?? TITLE := 'ifp$_detach_job', EJECT ??

  PROCEDURE [XDCL] ifp$_detach_job
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$detj) detach_job, detj (
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 1, 17, 46, 11, 704],
    clc$command, 1, 1, 0, 0, 0, 0, 1, 'OSM$DETJ'], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$status = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    jmp$detach_timesharing_job (status);

  PROCEND ifp$_detach_job;
?? TITLE := 'ifp$_display_connection_attribue', EJECT ??

  PROCEDURE [XDCL] ifp$_display_connection_attribu
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$distca) display_connection_attributes, display_connection_attribute, ..
{ display_term_conn_attributes, display_term_conn_attribute, distca, disca (
{   terminal_file_name, tfn: file = $required
{   display_options, display_option, do: any of
{       key
{         all
{       keyend
{       list of key
{         (attention_character_action, aca)
{         (break_key_action, bka)
{         (end_of_information, eoi)
{         (input_block_size, ibs)
{         (input_editing_mode, iem)
{         (input_output_mode, iom)
{         (input_timeout, it)
{         (input_timeout_length, itl)
{         (input_timeout_purge, itp)
{         (partial_character_forwarding, pcf)
{         (prompt_file, pf)
{         (prompt_string, ps)
{         (store_backspace_character, sbc)
{         (store_nuls_dels, snd)
{         (transparent_character_mode, tcm)
{         (transparent_forward_character, tfc)
{         (transparent_length_mode, tlm)
{         (transparent_message_length, tml)
{         (transparent_protocol_mode, tpm)
{         (transparent_terminate_character, ttc)
{         (transparent_timeout_mode, ttm)
{       keyend
{     anyend = all
{   output, o: file = $output
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 8] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 42] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 2, 17, 38, 2, 272],
    clc$command, 8, 4, 1, 0, 0, 0, 4, 'OSM$DISTCA'], [
    ['DISPLAY_OPTION                 ',clc$alias_entry, 2],
    ['DISPLAY_OPTIONS                ',clc$nominal_entry, 2],
    ['DO                             ',clc$abbreviation_entry, 2],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['STATUS                         ',clc$nominal_entry, 4],
    ['TERMINAL_FILE_NAME             ',clc$nominal_entry, 1],
    ['TFN                            ',clc$abbreviation_entry, 1]],
    [
{ PARAMETER 1
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1641,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 3
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    1577, [[1, 0, clc$list_type], [1561, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [42], [
        ['ACA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['ATTENTION_CHARACTER_ACTION     ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['BKA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['BREAK_KEY_ACTION               ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['END_OF_INFORMATION             ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['EOI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['IBS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['IEM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['INPUT_BLOCK_SIZE               ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['INPUT_EDITING_MODE             ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['INPUT_OUTPUT_MODE              ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['INPUT_TIMEOUT                  ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['INPUT_TIMEOUT_LENGTH           ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['INPUT_TIMEOUT_PURGE            ', clc$nominal_entry, clc$normal_usage_entry, 9],
        ['IOM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['IT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
        ['ITL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
        ['ITP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
        ['PARTIAL_CHARACTER_FORWARDING   ', clc$nominal_entry, clc$normal_usage_entry, 10],
        ['PCF                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
        ['PF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
        ['PROMPT_FILE                    ', clc$nominal_entry, clc$normal_usage_entry, 11],
        ['PROMPT_STRING                  ', clc$nominal_entry, clc$normal_usage_entry, 12],
        ['PS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
        ['SBC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
        ['SND                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
        ['STORE_BACKSPACE_CHARACTER      ', clc$nominal_entry, clc$normal_usage_entry, 13],
        ['STORE_NULS_DELS                ', clc$nominal_entry, clc$normal_usage_entry, 14],
        ['TCM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
        ['TFC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
        ['TLM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
        ['TML                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
        ['TPM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_CHARACTER_MODE     ', clc$nominal_entry, clc$normal_usage_entry, 15],
        ['TRANSPARENT_FORWARD_CHARACTER  ', clc$nominal_entry, clc$normal_usage_entry, 16],
        ['TRANSPARENT_LENGTH_MODE        ', clc$nominal_entry, clc$normal_usage_entry, 17],
        ['TRANSPARENT_MESSAGE_LENGTH     ', clc$nominal_entry, clc$normal_usage_entry, 18],
        ['TRANSPARENT_PROTOCOL_MODE      ', clc$nominal_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_TERMINATE_CHARACTER', clc$nominal_entry, clc$normal_usage_entry, 20],
        ['TRANSPARENT_TIMEOUT_MODE       ', clc$nominal_entry, clc$normal_usage_entry, 21],
        ['TTC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
        ['TTM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21]]
        ]
      ]
    ,
    'all'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$terminal_file_name = 1,
      p$display_options = 2,
      p$output = 3,
      p$status = 4;

    VAR
      pvt: array [1 .. 4] of clt$parameter_value;

    VAR
      attributes_value: ^clt$data_value,
      work_area: ^^clt$work_area;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    clp$get_work_area (#RING (^work_area), work_area, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    make_term_conn_attr_record (TRUE, pvt [p$terminal_file_name].value^.file_value, pvt [p$display_options],
          work_area^, attributes_value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_attributes ('display_connection_attributes', pvt [p$terminal_file_name].value^.file_value,
          attributes_value, pvt [p$output].value^.file_value^, work_area^, status);

  PROCEND ifp$_display_connection_attribu;
?? TITLE := 'ifp$_display_term_conn_defaults', EJECT ??

  PROCEDURE [XDCL] ifp$_display_term_conn_defaults
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$distcd) display_term_conn_defaults, display_term_conn_attributes, distcd (
{   display_options, display_option, do: any of
{       key
{         all
{       keyend
{       list of key
{         (attention_character_action, aca)
{         (break_key_action, bka)
{         (end_of_information, eoi)
{         (input_block_size, ibs)
{         (input_editing_mode, iem)
{         (input_output_mode, iom)
{         (input_timeout, it)
{         (input_timeout_length, itl)
{         (input_timeout_purge, itp)
{         (partial_character_forwarding, pcf)
{         (prompt_file, pf)
{         (prompt_string, ps)
{         (store_backspace_character, sbc)
{         (store_nuls_dels, snd)
{         (transparent_character_mode, tcm)
{         (transparent_forward_character, tfc)
{         (transparent_length_mode, tlm)
{         (transparent_message_length, tml)
{         (transparent_protocol_mode, tpm)
{         (transparent_terminate_character, ttc)
{         (transparent_timeout_mode, ttm)
{       keyend
{     anyend = all
{   output, o: file = $output
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 6] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 42] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 1, 18, 16, 9, 0],
    clc$command, 6, 3, 0, 0, 0, 0, 3, 'OSM$DISTCD'], [
    ['DISPLAY_OPTION                 ',clc$alias_entry, 1],
    ['DISPLAY_OPTIONS                ',clc$nominal_entry, 1],
    ['DO                             ',clc$abbreviation_entry, 1],
    ['O                              ',clc$abbreviation_entry, 2],
    ['OUTPUT                         ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 1641,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 3
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    1577, [[1, 0, clc$list_type], [1561, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [42], [
        ['ACA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
        ['ATTENTION_CHARACTER_ACTION     ', clc$nominal_entry, clc$normal_usage_entry, 1],
        ['BKA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
        ['BREAK_KEY_ACTION               ', clc$nominal_entry, clc$normal_usage_entry, 2],
        ['END_OF_INFORMATION             ', clc$nominal_entry, clc$normal_usage_entry, 3],
        ['EOI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
        ['IBS                            ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
        ['IEM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
        ['INPUT_BLOCK_SIZE               ', clc$nominal_entry, clc$normal_usage_entry, 4],
        ['INPUT_EDITING_MODE             ', clc$nominal_entry, clc$normal_usage_entry, 5],
        ['INPUT_OUTPUT_MODE              ', clc$nominal_entry, clc$normal_usage_entry, 6],
        ['INPUT_TIMEOUT                  ', clc$nominal_entry, clc$normal_usage_entry, 7],
        ['INPUT_TIMEOUT_LENGTH           ', clc$nominal_entry, clc$normal_usage_entry, 8],
        ['INPUT_TIMEOUT_PURGE            ', clc$nominal_entry, clc$normal_usage_entry, 9],
        ['IOM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 6],
        ['IT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 7],
        ['ITL                            ', clc$abbreviation_entry, clc$normal_usage_entry, 8],
        ['ITP                            ', clc$abbreviation_entry, clc$normal_usage_entry, 9],
        ['PARTIAL_CHARACTER_FORWARDING   ', clc$nominal_entry, clc$normal_usage_entry, 10],
        ['PCF                            ', clc$abbreviation_entry, clc$normal_usage_entry, 10],
        ['PF                             ', clc$abbreviation_entry, clc$normal_usage_entry, 11],
        ['PROMPT_FILE                    ', clc$nominal_entry, clc$normal_usage_entry, 11],
        ['PROMPT_STRING                  ', clc$nominal_entry, clc$normal_usage_entry, 12],
        ['PS                             ', clc$abbreviation_entry, clc$normal_usage_entry, 12],
        ['SBC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 13],
        ['SND                            ', clc$abbreviation_entry, clc$normal_usage_entry, 14],
        ['STORE_BACKSPACE_CHARACTER      ', clc$nominal_entry, clc$normal_usage_entry, 13],
        ['STORE_NULS_DELS                ', clc$nominal_entry, clc$normal_usage_entry, 14],
        ['TCM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 15],
        ['TFC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 16],
        ['TLM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 17],
        ['TML                            ', clc$abbreviation_entry, clc$normal_usage_entry, 18],
        ['TPM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_CHARACTER_MODE     ', clc$nominal_entry, clc$normal_usage_entry, 15],
        ['TRANSPARENT_FORWARD_CHARACTER  ', clc$nominal_entry, clc$normal_usage_entry, 16],
        ['TRANSPARENT_LENGTH_MODE        ', clc$nominal_entry, clc$normal_usage_entry, 17],
        ['TRANSPARENT_MESSAGE_LENGTH     ', clc$nominal_entry, clc$normal_usage_entry, 18],
        ['TRANSPARENT_PROTOCOL_MODE      ', clc$nominal_entry, clc$normal_usage_entry, 19],
        ['TRANSPARENT_TERMINATE_CHARACTER', clc$nominal_entry, clc$normal_usage_entry, 20],
        ['TRANSPARENT_TIMEOUT_MODE       ', clc$nominal_entry, clc$normal_usage_entry, 21],
        ['TTC                            ', clc$abbreviation_entry, clc$normal_usage_entry, 20],
        ['TTM                            ', clc$abbreviation_entry, clc$normal_usage_entry, 21]]
        ]
      ]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$display_options = 1,
      p$output = 2,
      p$status = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

    VAR
      attributes_value: ^clt$data_value,
      work_area: ^^clt$work_area;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    clp$get_work_area (#RING (^work_area), work_area, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    make_term_conn_attr_record (TRUE, NIL, pvt [p$display_options], work_area^, attributes_value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_attributes ('display_term_conn_attributes', NIL, attributes_value,
          pvt [p$output].value^.file_value^, work_area^, status);

  PROCEND ifp$_display_term_conn_defaults;
?? TITLE := 'ifp$_display_terminal_attribute', EJECT ??

  PROCEDURE [XDCL] ifp$_display_terminal_attribute
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{   PROCEDURE (osm$dista) display_terminal_attributes, display_terminal_attri..
{ bute, dista (
{     display_options, display_option, do: any of
{         key
{           all
{         keyend
{         list of key
{           (attention_character, ac)
{           (backspace_character, bc)
{           (begin_line_character, blc)
{           (cancel_line_character, clc)
{           (carriage_return_delay, crd)
{           (carriage_return_sequence, crs)
{           (character_flow_control, cfc)
{           (code_set, cs)
{           (connect_view, cv)
{           (control_code_replacement, ccr)
{           (echoplex, e)
{           (end_line_character, elc)
{           (end_line_positioning, elp)
{           (end_output_sequence, eos)
{           (end_page_action, epa)
{           (end_partial_character, epc)
{           (end_partial_positioning, epp)
{           (fold_line, fl)
{           (form_feed_delay, ffd)
{           (form_feed_sequence, ffs)
{           (function_key_class, fkc)
{           (hold_page, hp)
{           (hold_page_over, hpo)
{           (line_feed_delay, lfd)
{           (line_feed_sequence, lfs)
{           (network, n)
{           (network_command_character, ncc)
{           (page_length, pl)
{           (page_width, pw)
{           (parity, p)
{           (pause_break_character, pbc)
{           (status_action, sa)
{           (terminal_class, tc)
{           (terminal_model, trm, tm)
{           (terminal_name, tn)
{           (terminate_break_character, tbc)
{         keyend
{       anyend = all
{     output, o: file = $output
{     status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 6] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 73] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type3: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 10, 12, 9, 4, 35, 474],
    clc$command, 6, 3, 0, 0, 0, 0, 3, 'OSM$DISTA'], [
    ['DISPLAY_OPTION                 ',clc$alias_entry, 1],
    ['DISPLAY_OPTIONS                ',clc$nominal_entry, 1],
    ['DO                             ',clc$abbreviation_entry, 1],
    ['O                              ',clc$abbreviation_entry, 2],
    ['OUTPUT                         ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 2788, clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_default_parameter, 0, 7],
{ PARAMETER 3
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    2724, [[1, 0, clc$list_type], [2708, 1, clc$max_list_size, 0, FALSE, FALSE]
  ,
        [[1, 0, clc$keyword_type], [73], [
        ['AC                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
        ['ATTENTION_CHARACTER            ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
        ['BACKSPACE_CHARACTER            ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
        ['BC                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
        ['BEGIN_LINE_CHARACTER           ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
        ['BLC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
        ['CANCEL_LINE_CHARACTER          ', clc$nominal_entry,
  clc$normal_usage_entry, 4],
        ['CARRIAGE_RETURN_DELAY          ', clc$nominal_entry,
  clc$normal_usage_entry, 5],
        ['CARRIAGE_RETURN_SEQUENCE       ', clc$nominal_entry,
  clc$normal_usage_entry, 6],
        ['CCR                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 10],
        ['CFC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 7],
        ['CHARACTER_FLOW_CONTROL         ', clc$nominal_entry,
  clc$normal_usage_entry, 7],
        ['CLC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 4],
        ['CODE_SET                       ', clc$nominal_entry,
  clc$normal_usage_entry, 8],
        ['CONNECT_VIEW                   ', clc$nominal_entry,
  clc$normal_usage_entry, 9],
        ['CONTROL_CODE_REPLACEMENT       ', clc$nominal_entry,
  clc$normal_usage_entry, 10],
        ['CRD                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 5],
        ['CRS                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 6],
        ['CS                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 8],
        ['CV                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 9],
        ['E                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 11],
        ['ECHOPLEX                       ', clc$nominal_entry,
  clc$normal_usage_entry, 11],
        ['ELC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 12],
        ['ELP                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 13],
        ['END_LINE_CHARACTER             ', clc$nominal_entry,
  clc$normal_usage_entry, 12],
        ['END_LINE_POSITIONING           ', clc$nominal_entry,
  clc$normal_usage_entry, 13],
        ['END_OUTPUT_SEQUENCE            ', clc$nominal_entry,
  clc$normal_usage_entry, 14],
        ['END_PAGE_ACTION                ', clc$nominal_entry,
  clc$normal_usage_entry, 15],
        ['END_PARTIAL_CHARACTER          ', clc$nominal_entry,
  clc$normal_usage_entry, 16],
        ['END_PARTIAL_POSITIONING        ', clc$nominal_entry,
  clc$normal_usage_entry, 17],
        ['EOS                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 14],
        ['EPA                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 15],
        ['EPC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 16],
        ['EPP                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 17],
        ['FFD                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 19],
        ['FFS                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 20],
        ['FKC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 21],
        ['FL                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 18],
        ['FOLD_LINE                      ', clc$nominal_entry,
  clc$normal_usage_entry, 18],
        ['FORM_FEED_DELAY                ', clc$nominal_entry,
  clc$normal_usage_entry, 19],
        ['FORM_FEED_SEQUENCE             ', clc$nominal_entry,
  clc$normal_usage_entry, 20],
        ['FUNCTION_KEY_CLASS             ', clc$nominal_entry,
  clc$normal_usage_entry, 21],
        ['HOLD_PAGE                      ', clc$nominal_entry,
  clc$normal_usage_entry, 22],
        ['HOLD_PAGE_OVER                 ', clc$nominal_entry,
  clc$normal_usage_entry, 23],
        ['HP                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 22],
        ['HPO                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 23],
        ['LFD                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 24],
        ['LFS                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 25],
        ['LINE_FEED_DELAY                ', clc$nominal_entry,
  clc$normal_usage_entry, 24],
        ['LINE_FEED_SEQUENCE             ', clc$nominal_entry,
  clc$normal_usage_entry, 25],
        ['N                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 26],
        ['NCC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 27],
        ['NETWORK                        ', clc$nominal_entry,
  clc$normal_usage_entry, 26],
        ['NETWORK_COMMAND_CHARACTER      ', clc$nominal_entry,
  clc$normal_usage_entry, 27],
        ['P                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 30],
        ['PAGE_LENGTH                    ', clc$nominal_entry,
  clc$normal_usage_entry, 28],
        ['PAGE_WIDTH                     ', clc$nominal_entry,
  clc$normal_usage_entry, 29],
        ['PARITY                         ', clc$nominal_entry,
  clc$normal_usage_entry, 30],
        ['PAUSE_BREAK_CHARACTER          ', clc$nominal_entry,
  clc$normal_usage_entry, 31],
        ['PBC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 31],
        ['PL                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 28],
        ['PW                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 29],
        ['SA                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 32],
        ['STATUS_ACTION                  ', clc$nominal_entry,
  clc$normal_usage_entry, 32],
        ['TBC                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 36],
        ['TC                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 33],
        ['TERMINAL_CLASS                 ', clc$nominal_entry,
  clc$normal_usage_entry, 33],
        ['TERMINAL_MODEL                 ', clc$nominal_entry,
  clc$normal_usage_entry, 34],
        ['TERMINAL_NAME                  ', clc$nominal_entry,
  clc$normal_usage_entry, 35],
        ['TERMINATE_BREAK_CHARACTER      ', clc$nominal_entry,
  clc$normal_usage_entry, 36],
        ['TM                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 34],
        ['TN                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 35],
        ['TRM                            ', clc$alias_entry,
  clc$normal_usage_entry, 34]]
        ]
      ]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 3
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$display_options = 1,
      p$output = 2,
      p$status = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

    VAR
      attributes_value: ^clt$data_value,
      work_area: ^^clt$work_area;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    clp$get_work_area (#RING (^work_area), work_area, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    make_term_attr_record (TRUE, pvt [p$display_options], work_area^, attributes_value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_attributes ('display_terminal_attributes', NIL, attributes_value, pvt [p$output].value^.
          file_value^, work_area^, status);

  PROCEND ifp$_display_terminal_attribute;
?? TITLE := 'ifp$_request_terminal', EJECT ??

  PROCEDURE [XDCL] ifp$_request_terminal
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$reqt) request_terminal, reqt (
{   file, f: file = $required
{   attention_character_action, aca: (BY_NAME) integer 0..9 = $optional
{   break_key_action, bka: (BY_NAME) integer 0..9 = $optional
{   end_of_information, eoi: (BY_NAME) string 0..31 = $optional
{   input_block_size, ibs: (BY_NAME) integer 80..2000 = $optional
{   input_editing_mode, iem: (BY_NAME) key
{       (normal, n)
{       (transparent, t)
{     keyend = $optional
{   input_output_mode, iom: (BY_NAME) key
{       (unsolicited, u)
{       (solicited, s)
{       (full_duplex, fullduplex, f)
{     keyend = $optional
{   input_timeout, it: (BY_NAME) boolean = $optional
{   input_timeout_length, itl: (BY_NAME) integer 0..1048575 = $optional
{   input_timeout_purge, itp: (BY_NAME) boolean = $optional
{   partial_character_forwarding, pcf: (BY_NAME) boolean = $optional
{   prompt_file, pf: (BY_NAME) file = $optional
{   prompt_string, ps: (BY_NAME) string 0..31 = $optional
{   store_backspace_character, sbc: (BY_NAME) boolean = $optional
{   store_nuls_dels, snd: (BY_NAME) boolean = $optional
{   transparent_character_mode, tcm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{       (forward_terminate, ft)
{     keyend = $optional
{   transparent_forward_character, tfc: (BY_NAME) list 1..4 of string 1 = $optional
{   transparent_length_mode, tlm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{       (forward_exact, fe)
{     keyend = $optional
{   transparent_message_length, tml: (BY_NAME) integer 1..32767 = $optional
{   transparent_protocol_mode, tpm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{     keyend = $optional
{   transparent_terminate_character, ttc: (BY_NAME) list 1..4 of string 1 = $optional
{   transparent_timeout_mode, ttm: (BY_NAME) key
{       (none, n)
{       (terminate, t)
{       (forward, f)
{     keyend = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 45] of clt$pdt_parameter_name,
      parameters: array [1 .. 23] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 7] of clt$keyword_specification,
      recend,
      type8: record
        header: clt$type_specification_header,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type10: record
        header: clt$type_specification_header,
      recend,
      type11: record
        header: clt$type_specification_header,
      recend,
      type12: record
        header: clt$type_specification_header,
      recend,
      type13: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
      recend,
      type14: record
        header: clt$type_specification_header,
      recend,
      type15: record
        header: clt$type_specification_header,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type17: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type18: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type19: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
      recend,
      type20: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type21: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type22: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type23: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 3, 2, 12, 44, 28, 755],
    clc$command, 45, 23, 1, 0, 0, 0, 23, 'OSM$REQT'], [
    ['ACA                            ',clc$abbreviation_entry, 2],
    ['ATTENTION_CHARACTER_ACTION     ',clc$nominal_entry, 2],
    ['BKA                            ',clc$abbreviation_entry, 3],
    ['BREAK_KEY_ACTION               ',clc$nominal_entry, 3],
    ['END_OF_INFORMATION             ',clc$nominal_entry, 4],
    ['EOI                            ',clc$abbreviation_entry, 4],
    ['F                              ',clc$abbreviation_entry, 1],
    ['FILE                           ',clc$nominal_entry, 1],
    ['IBS                            ',clc$abbreviation_entry, 5],
    ['IEM                            ',clc$abbreviation_entry, 6],
    ['INPUT_BLOCK_SIZE               ',clc$nominal_entry, 5],
    ['INPUT_EDITING_MODE             ',clc$nominal_entry, 6],
    ['INPUT_OUTPUT_MODE              ',clc$nominal_entry, 7],
    ['INPUT_TIMEOUT                  ',clc$nominal_entry, 8],
    ['INPUT_TIMEOUT_LENGTH           ',clc$nominal_entry, 9],
    ['INPUT_TIMEOUT_PURGE            ',clc$nominal_entry, 10],
    ['IOM                            ',clc$abbreviation_entry, 7],
    ['IT                             ',clc$abbreviation_entry, 8],
    ['ITL                            ',clc$abbreviation_entry, 9],
    ['ITP                            ',clc$abbreviation_entry, 10],
    ['PARTIAL_CHARACTER_FORWARDING   ',clc$nominal_entry, 11],
    ['PCF                            ',clc$abbreviation_entry, 11],
    ['PF                             ',clc$abbreviation_entry, 12],
    ['PROMPT_FILE                    ',clc$nominal_entry, 12],
    ['PROMPT_STRING                  ',clc$nominal_entry, 13],
    ['PS                             ',clc$abbreviation_entry, 13],
    ['SBC                            ',clc$abbreviation_entry, 14],
    ['SND                            ',clc$abbreviation_entry, 15],
    ['STATUS                         ',clc$nominal_entry, 23],
    ['STORE_BACKSPACE_CHARACTER      ',clc$nominal_entry, 14],
    ['STORE_NULS_DELS                ',clc$nominal_entry, 15],
    ['TCM                            ',clc$abbreviation_entry, 16],
    ['TFC                            ',clc$abbreviation_entry, 17],
    ['TLM                            ',clc$abbreviation_entry, 18],
    ['TML                            ',clc$abbreviation_entry, 19],
    ['TPM                            ',clc$abbreviation_entry, 20],
    ['TRANSPARENT_CHARACTER_MODE     ',clc$nominal_entry, 16],
    ['TRANSPARENT_FORWARD_CHARACTER  ',clc$nominal_entry, 17],
    ['TRANSPARENT_LENGTH_MODE        ',clc$nominal_entry, 18],
    ['TRANSPARENT_MESSAGE_LENGTH     ',clc$nominal_entry, 19],
    ['TRANSPARENT_PROTOCOL_MODE      ',clc$nominal_entry, 20],
    ['TRANSPARENT_TERMINATE_CHARACTER',clc$nominal_entry, 21],
    ['TRANSPARENT_TIMEOUT_MODE       ',clc$nominal_entry, 22],
    ['TTC                            ',clc$abbreviation_entry, 21],
    ['TTM                            ',clc$abbreviation_entry, 22]],
    [
{ PARAMETER 1
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 4
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 5
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 6
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 266,
  clc$optional_parameter, 0, 0],
{ PARAMETER 8
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 9
    [15, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 10
    [16, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 11
    [21, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 12
    [24, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 13
    [25, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8, clc$optional_parameter, 0
  , 0],
{ PARAMETER 14
    [30, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 15
    [31, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 16
    [37, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 17
    [38, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 24, clc$optional_parameter,
  0, 0],
{ PARAMETER 18
    [39, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 303,
  clc$optional_parameter, 0, 0],
{ PARAMETER 19
    [40, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter,
  0, 0],
{ PARAMETER 20
    [41, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 21
    [42, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 24, clc$optional_parameter,
  0, 0],
{ PARAMETER 22
    [43, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 229,
  clc$optional_parameter, 0, 0],
{ PARAMETER 23
    [29, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [0, 9, 10]],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [0, 9, 10]],
{ PARAMETER 4
    [[1, 0, clc$string_type], [0, 31, FALSE]],
{ PARAMETER 5
    [[1, 0, clc$integer_type], [80, 2000, 10]],
{ PARAMETER 6
    [[1, 0, clc$keyword_type], [4], [
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NORMAL                         ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TRANSPARENT                    ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 7
    [[1, 0, clc$keyword_type], [7], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FULLDUPLEX                     ', clc$alias_entry, clc$normal_usage_entry, 3],
    ['FULL_DUPLEX                    ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['SOLICITED                      ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['U                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['UNSOLICITED                    ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 8
    [[1, 0, clc$boolean_type]],
{ PARAMETER 9
    [[1, 0, clc$integer_type], [0, 1048575, 10]],
{ PARAMETER 10
    [[1, 0, clc$boolean_type]],
{ PARAMETER 11
    [[1, 0, clc$boolean_type]],
{ PARAMETER 12
    [[1, 0, clc$file_type]],
{ PARAMETER 13
    [[1, 0, clc$string_type], [0, 31, FALSE]],
{ PARAMETER 14
    [[1, 0, clc$boolean_type]],
{ PARAMETER 15
    [[1, 0, clc$boolean_type]],
{ PARAMETER 16
    [[1, 0, clc$keyword_type], [8], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['FORWARD_TERMINATE              ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['FT                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 17
    [[1, 0, clc$list_type], [8, 1, 4, 0, FALSE, FALSE],
      [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 18
    [[1, 0, clc$keyword_type], [8], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FE                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['FORWARD_EXACT                  ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 19
    [[1, 0, clc$integer_type], [1, 32767, 10]],
{ PARAMETER 20
    [[1, 0, clc$keyword_type], [6], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 21
    [[1, 0, clc$list_type], [8, 1, 4, 0, FALSE, FALSE],
      [[1, 0, clc$string_type], [1, 1, FALSE]]
    ],
{ PARAMETER 22
    [[1, 0, clc$keyword_type], [6], [
    ['F                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['FORWARD                        ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['N                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['T                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['TERMINATE                      ', clc$nominal_entry, clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 23
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$file = 1,
      p$attention_character_action = 2,
      p$break_key_action = 3,
      p$end_of_information = 4,
      p$input_block_size = 5,
      p$input_editing_mode = 6,
      p$input_output_mode = 7,
      p$input_timeout = 8,
      p$input_timeout_length = 9,
      p$input_timeout_purge = 10,
      p$partial_character_forwarding = 11,
      p$prompt_file = 12,
      p$prompt_string = 13,
      p$store_backspace_character = 14,
      p$store_nuls_dels = 15,
      p$transparent_character_mode = 16,
      p$transparent_forward_character = 17,
      p$transparent_length_mode = 18,
      p$transparent_message_length = 19,
      p$transparent_protocol_mode = 20,
      p$transparent_terminate_charact = 21 {TRANSPARENT_TERMINATE_CHARACTER} ,
      p$transparent_timeout_mode = 22,
      p$status = 23;

    VAR
      pvt: array [1 .. 23] of clt$parameter_value;

    VAR
      attributes: ^ift$connection_attributes,
      attributes_area: ^SEQ ( * ),
      attribute_count: integer,
      attribute_limit: integer,
      file: clt$file,
      i: integer,
      local_file_name: amt$local_file_name,
      evaluated_file_reference: fst$evaluated_file_reference,
      null_attribute: [STATIC, READ, oss$job_paged_literal] array
            [1 .. 1] of ift$connection_attribute := [[ifc$null_connection_attribute]],
      node: ^clt$data_value,
      terminal_lfn_loc: ^amt$local_file_name;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;

    clp$convert_string_to_file (pvt [p$file].value^.file_value^, file, status);
    local_file_name := file.local_file_name;

    clp$get_fs_path_elements (local_file_name, evaluated_file_reference, status);

    IF (fsp$path_element (^evaluated_file_reference, 1) ^ <> fsc$local) OR
          (evaluated_file_reference.number_of_path_elements = 1) THEN
      osp$set_status_abnormal ('CL', cle$only_permitted_on_loc_file, '', status);
      RETURN;
    IFEND;

    attribute_limit := $INTEGER (ifc$max_connection_key);
    PUSH attributes_area: [[REP attribute_limit OF ift$connection_attribute]];
    RESET attributes_area;
    NEXT attributes: [1 .. attribute_limit] IN attributes_area;
    attribute_count := 0;

    IF pvt [p$attention_character_action].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$attention_character_action;
      attributes^ [attribute_count].attention_character_action :=
            pvt [p$attention_character_action].value^.integer_value.value;
    IFEND;

    IF pvt [p$break_key_action].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$break_key_action;
      attributes^ [attribute_count].break_key_action := pvt [p$break_key_action].value^.integer_value.value;
    IFEND;

    IF pvt [p$end_of_information].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$end_of_information;
      attributes^ [attribute_count].end_of_information.size :=
            clp$trimmed_string_size (pvt [p$end_of_information].value^.string_value^);
      attributes^ [attribute_count].end_of_information.value := pvt [p$end_of_information].value^.
            string_value^;
    IFEND;

    IF pvt [p$input_block_size].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_block_size;
      attributes^ [attribute_count].input_block_size := pvt [p$input_block_size].value^.integer_value.value;
    IFEND;

    IF pvt [p$input_editing_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_editing_mode;
      IF pvt [p$input_editing_mode].value^.keyword_value = 'NORMAL' THEN
        attributes^ [attribute_count].input_editing_mode := ifc$normal_edit;
      ELSEIF pvt [p$input_editing_mode].value^.keyword_value = 'TRANSPARENT' THEN
        attributes^ [attribute_count].input_editing_mode := ifc$trans_edit;
      IFEND;
    IFEND;

    IF pvt [p$input_output_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_output_mode;
      IF pvt [p$input_output_mode].value^.keyword_value = 'UNSOLICITED' THEN
        attributes^ [attribute_count].input_output_mode := ifc$unsolicited_output;
      ELSEIF pvt [p$input_output_mode].value^.keyword_value = 'SOLICITED' THEN
        attributes^ [attribute_count].input_output_mode := ifc$solicited;
      ELSEIF pvt [p$input_output_mode].value^.keyword_value = 'FULL_DUPLEX' THEN
        attributes^ [attribute_count].input_output_mode := ifc$full_duplex;
      IFEND;
    IFEND;

    IF pvt [p$input_timeout].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_timeout;
      attributes^ [attribute_count].input_timeout := pvt [p$input_timeout].value^.boolean_value.value;
    IFEND;

    IF pvt [p$input_timeout_length].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_timeout_length;
      attributes^ [attribute_count].input_timeout_length :=
            pvt [p$input_timeout_length].value^.integer_value.value;
    IFEND;

    IF pvt [p$input_timeout_purge].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$input_timeout_purge;
      attributes^ [attribute_count].input_timeout_purge :=
            pvt [p$input_timeout_purge].value^.boolean_value.value;
    IFEND;

    IF pvt [p$partial_character_forwarding].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$partial_char_forwarding;
      attributes^ [attribute_count].partial_character_forwarding := pvt [p$partial_character_forwarding].
            value^.boolean_value.value;
    IFEND;

    IF pvt [p$prompt_file].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$prompt_file;
      clp$convert_string_to_file (pvt [p$prompt_file].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      attributes^ [attribute_count].prompt_file := file.local_file_name;
    IFEND;

    IF pvt [p$prompt_string].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$prompt_string;
      attributes^ [attribute_count].prompt_string.size := STRLENGTH (pvt [p$prompt_string].value^.
            string_value^);
      attributes^ [attribute_count].prompt_string.value := pvt [p$prompt_string].value^.string_value^;
    IFEND;

    IF pvt [p$store_backspace_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$store_backspace_character;
      attributes^ [attribute_count].store_backspace_character :=
            pvt [p$store_backspace_character].value^.boolean_value.value;
    IFEND;

    IF pvt [p$store_nuls_dels].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$store_nuls_dels;
      attributes^ [attribute_count].store_nuls_dels := pvt [p$store_nuls_dels].value^.boolean_value.value;
    IFEND;

    IF pvt [p$transparent_character_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_character_mode;
      IF pvt [p$transparent_character_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$no_trans_char;
      ELSEIF pvt [p$transparent_character_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$trans_char_terminate;
      ELSEIF pvt [p$transparent_character_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$trans_char_forward;
      ELSEIF pvt [p$transparent_character_mode].value^.keyword_value = 'FORWARD_TERMINATE' THEN
        attributes^ [attribute_count].trans_character_mode := ifc$trans_char_fwd_terminate;
      IFEND;
    IFEND;

    IF pvt [p$transparent_forward_character].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_forward_character;
      node := pvt [p$transparent_forward_character].value;
      i := 0;
      WHILE node <> NIL DO
        i := i + 1;
        attributes^ [attribute_count].trans_forward_character.value (i) :=
              node^.element_value^.string_value^ (1);
        node := node^.link;
      WHILEND;
      attributes^ [attribute_count].trans_forward_character.size := i;
    IFEND;

    IF pvt [p$transparent_length_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_length_mode;
      IF pvt [p$transparent_length_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$no_trans_len;
      ELSEIF pvt [p$transparent_length_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$trans_len_terminate;
      ELSEIF pvt [p$transparent_length_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$trans_len_forward;
      ELSEIF pvt [p$transparent_length_mode].value^.keyword_value = 'FORWARD_EXACT' THEN
        attributes^ [attribute_count].trans_length_mode := ifc$trans_len_forward_exact;
      IFEND;
    IFEND;

    IF pvt [p$transparent_message_length].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_message_length;
      attributes^ [attribute_count].trans_message_length :=
            pvt [p$transparent_message_length].value^.integer_value.value;
    IFEND;

    IF pvt [p$transparent_terminate_charact].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_terminate_character;
      node := pvt [p$transparent_terminate_charact].value;
      i := 0;
      WHILE node <> NIL DO
        i := i + 1;
        attributes^ [attribute_count].trans_terminate_character.value (i, 1) :=
              node^.element_value^.string_value^ (1, 1);
        node := node^.link;
      WHILEND;
      attributes^ [attribute_count].trans_terminate_character.size := i;
    IFEND;

    IF pvt [p$transparent_timeout_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_timeout_mode;
      IF pvt [p$transparent_timeout_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_timeout_mode := ifc$no_trans_timeout;
      ELSEIF pvt [p$transparent_timeout_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_timeout_mode := ifc$trans_timeout_terminate;
      ELSEIF pvt [p$transparent_timeout_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_timeout_mode := ifc$trans_timeout_forward;
      IFEND;
    IFEND;

    IF pvt [p$transparent_protocol_mode].specified THEN
      attribute_count := attribute_count + 1;
      attributes^ [attribute_count].key := ifc$trans_protocol_mode;
      IF pvt [p$transparent_protocol_mode].value^.keyword_value = 'NONE' THEN
        attributes^ [attribute_count].trans_protocol_mode := ifc$no_trans_protocol;
      ELSEIF pvt [p$transparent_protocol_mode].value^.keyword_value = 'TERMINATE' THEN
        attributes^ [attribute_count].trans_protocol_mode := ifc$trans_protocol_terminate;
      ELSEIF pvt [p$transparent_protocol_mode].value^.keyword_value = 'FORWARD' THEN
        attributes^ [attribute_count].trans_protocol_mode := ifc$trans_protocol_forward;
      IFEND;
    IFEND;

    IF attribute_count = 0 THEN
      attributes := ^null_attribute;
    ELSE
      RESET attributes_area;
      NEXT attributes: [1 .. attribute_count] IN attributes_area;
    IFEND;

    terminal_lfn_loc := NIL;
    rmp$request_terminal (local_file_name, terminal_lfn_loc, attributes^, status);

  PROCEND ifp$_request_terminal;
?? TITLE := 'make_term_attr_record', EJECT ??

  PROCEDURE make_term_attr_record
    (    make_for_display: boolean;
         options: clt$parameter_value;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    CONST
      pc_connect_ = 'PC_CONNECT_';

    TYPE
      terminal_attributes = set of ift$terminal_attribute_keys;

    VAR
      code_sets: [STATIC, READ, oss$job_paged_literal] array [ift$code_set] of string (17) := ['ASCII',
            'BPAPL', 'TPAPL', 'Use Code_Set_Name'],
      end_line_positions: [STATIC, READ, oss$job_paged_literal] array [ift$end_line_positioning] of
            string (6) := ['NONE', 'CRS', 'LFS', 'CRSLFS'],
      end_page_actions: [STATIC, READ, oss$job_paged_literal] array [ift$end_page_action] of string (4) :=
            ['NONE', 'FFS'],
      end_partial_positions: [STATIC, READ, oss$job_paged_literal] array [ift$end_partial_positioning] of
            string (6) := ['NONE', 'CRS', 'LFS', 'CRSLFS'],
      network_identifiers: [STATIC, READ, oss$job_paged_literal] array [0 .. ifc$max_network_identifier] of
            string (13) := ['NONE', 'NAM/VE CDCNET', 'NAM CDCNET', 'NAM CCP', 'INTERCOM'],
      parity_modes: [STATIC, READ, oss$job_paged_literal] array [ift$parity] of string (4) := ['ZERO', 'MARK',
            'EVEN', 'ODD', 'NONE'],
      status_actions: [STATIC, READ, oss$job_paged_literal] array [ift$status_action] of string (7) :=
            ['SEND', 'HOLD', 'DISCARD'],
      terminal_classes: [STATIC, READ, oss$job_paged_literal] array [ift$terminal_class] of string (9) :=
            ['TTY', 'CDC75X', 'CDC721', 'IBM2741', 'TTY40', 'HP2000', 'X364', 'T4010', 'HASP_POST',
            'CDC200UT', 'CDC714_30', 'CDC711', 'CDC714_10', 'HASP_PRE', 'CDC73X', 'IBM2740', 'IBM3780',
            'IBM3270'];

    VAR
      attribute_count: clt$list_size,
      attribute_key: ift$terminal_attribute_keys,
      attribute_set: terminal_attributes,
      attributes: ^ift$terminal_attributes,
      code_set_name: ost$name,
      connect_view: boolean,
      connect_view_requested: boolean,
      current_node: ^^clt$data_value,
      i: clt$list_size,
      j: integer,
      network_identifier: ift$network_identifier,
      network_requested: boolean,
      option: ^clt$data_value,
      original_code_high: char,
      original_code_low: char,
      requested_attributes: ^ift$terminal_attributes,
      substitute_code: char,
      terminal_model_requested: boolean;


    status.normal := TRUE;
    result := NIL;

    IF options.value^.kind = clc$keyword {ALL} THEN
      attribute_set := -$terminal_attributes [] - $terminal_attributes
            [ifc$null_terminal_attribute, ifc$code_set_name];
      connect_view_requested := TRUE;
      network_requested := TRUE;
      terminal_model_requested := TRUE;
    ELSE {clc$list}
      attribute_set := $terminal_attributes [];
      connect_view_requested := FALSE;
      network_requested := FALSE;
      terminal_model_requested := FALSE;
      option := options.value;
      WHILE option <> NIL DO
        IF option^.element_value^.keyword_value = 'CONNECT_VIEW' THEN
          connect_view_requested := TRUE;
          attribute_set := attribute_set + $terminal_attributes [ifc$terminal_model];
        ELSEIF option^.element_value^.keyword_value = 'NETWORK' THEN
          network_requested := TRUE;
        ELSEIF option^.element_value^.keyword_value = 'TERMINAL_MODEL' THEN
          terminal_model_requested := TRUE;
          attribute_set := attribute_set + $terminal_attributes [ifc$terminal_model];
        ELSE
          get_terminal_attribute_key (option^.element_value^.keyword_value, attribute_key);
          attribute_set := attribute_set + $terminal_attributes [attribute_key];
        IFEND;
        option := option^.link;
      WHILEND;
    IFEND;

    i := 0;
    FOR attribute_key := ifc$attention_character TO ifc$max_terminal_attribute_key DO
      i := i + $INTEGER (attribute_key IN attribute_set);
    FOREND;

    IF i = 0 THEN {only NETWORK requested}
      clp$make_record_value (1, work_area, result);

    ELSE
      PUSH attributes: [1 .. i];
      PUSH requested_attributes: [1 .. i];
      i := 0;

      FOR attribute_key := ifc$attention_character TO ifc$max_terminal_attribute_key DO
        IF attribute_key IN attribute_set THEN
          i := i + 1;
          attributes^ [i].key := attribute_key;
          IF attribute_key = ifc$terminal_name THEN
            PUSH attributes^ [i].terminal_name;
          IFEND;
          IF attribute_key = ifc$control_code_replacement THEN
            PUSH attributes^ [i].control_code_replacement;
          IFEND;
          IF attribute_key = ifc$code_set THEN
            PUSH attributes^ [i].code_set_name;
          IFEND;
          IF attribute_key = ifc$function_key_class THEN
            PUSH attributes^ [i].function_key_class;
          IFEND;
        IFEND;
      FOREND;

      requested_attributes^ := attributes^;
      ifp$get_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name, attributes^,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      clp$make_record_value (UPPERBOUND (attributes^) + $INTEGER (connect_view_requested AND
            terminal_model_requested) + $INTEGER (network_requested), work_area, result);

      FOR i := 1 TO UPPERBOUND (attributes^) DO
        CASE requested_attributes^ [i].key OF

        = ifc$attention_character =
          result^.field_values^ [i].name := 'ATTENTION_CHARACTER';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_char_value (attributes^ [i].attention_character, work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$backspace_character =
          result^.field_values^ [i].name := 'BACKSPACE_CHARACTER';
          clp$make_char_value (attributes^ [i].backspace_character, work_area, result^.field_values^ [i].
                value);

        = ifc$begin_line_character =
          result^.field_values^ [i].name := 'BEGIN_LINE_CHARACTER';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_char_value (attributes^ [i].begin_line_character, work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$cancel_line_character =
          result^.field_values^ [i].name := 'CANCEL_LINE_CHARACTER';
          clp$make_char_value (attributes^ [i].cancel_line_character, work_area,
                result^.field_values^ [i].value);

        = ifc$carriage_return_delay =
          result^.field_values^ [i].name := 'CARRIAGE_RETURN_DELAY';
          clp$make_integer_value (attributes^ [i].carriage_return_delay, 10, FALSE, work_area,
                result^.field_values^ [i].value);

        = ifc$carriage_return_sequence =
          result^.field_values^ [i].name := 'CARRIAGE_RETURN_SEQUENCE';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_string_value (attributes^ [i].carriage_return_sequence.
                  value (1, attributes^ [i].carriage_return_sequence.size),
                  work_area, result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$character_flow_control =
          result^.field_values^ [i].name := 'CHARACTER_FLOW_CONTROL';
          clp$make_boolean_value (attributes^ [i].character_flow_control, clc$yes_no_boolean, work_area,
                result^.field_values^ [i].value);

        = ifc$code_set =
          result^.field_values^ [i].name := 'CODE_SET';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            IF attributes^ [i].key = ifc$code_set_name THEN
              code_set_name := attributes^ [i].code_set_name^.value (1, attributes^ [i].code_set_name^.size);
              IF code_set_name = '' THEN
                clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
              ELSEIF (code_set_name = 'ASCII48') OR (code_set_name = 'ASCII64') OR
                    (code_set_name = 'ASCII95') OR (code_set_name = 'ASCII128') OR
                    (code_set_name = 'ASCII256') OR (code_set_name = 'EBCDIC') THEN
                clp$make_keyword_value (code_set_name, work_area, result^.field_values^ [i].value);
              ELSE
                clp$make_name_value (code_set_name, work_area, result^.field_values^ [i].value);
              IFEND;
            ELSE
              clp$make_keyword_value (code_sets [attributes^ [i].code_set],
                    work_area, result^.field_values^ [i].value);
            IFEND;
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$control_code_replacement =
          result^.field_values^ [i].name := 'CONTROL_CODE_REPLACEMENT';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            IF attributes^ [i].control_code_replacement^.total_substitution_count = 0 THEN
              clp$make_keyword_value ('NONE', work_area, result^.field_values^ [i].value);
            ELSE
              current_node := ^result^.field_values^ [i].value;
              j := 1;
              WHILE j <= attributes^ [i].control_code_replacement^.total_substitution_count DO
                original_code_low := attributes^ [i].control_code_replacement^.value [j].
                      original_control_code;
                substitute_code := attributes^ [i].control_code_replacement^.value [j].
                      substitute_control_code;
                WHILE (j < attributes^ [i].control_code_replacement^.total_substitution_count) AND
                      (attributes^ [i].control_code_replacement^.value [j + 1].substitute_control_code =
                      substitute_code) AND (attributes^ [i].control_code_replacement^.value [j +
                      1].original_control_code = SUCC (attributes^ [i].control_code_replacement^.value [j].
                      original_control_code)) DO
                  j := j + 1;
                WHILEND;
                original_code_high := attributes^ [i].control_code_replacement^.value [j].
                      original_control_code;
                clp$make_list_value (work_area, current_node^);
                clp$make_record_value (2, work_area, current_node^^.element_value);
                current_node^^.element_value^.field_values^ [1].name := 'ORIGINAL';
                current_node^^.element_value^.field_values^ [2].name := 'SUBSTITUTE';
                clp$make_range_value (work_area, current_node^^.element_value^.field_values^ [1].value);
                clp$make_char_value (original_code_low, work_area,
                      current_node^^.element_value^.field_values^ [1].value^.low_value);
                IF original_code_high = original_code_low THEN
                  current_node^^.element_value^.field_values^ [1].value^.high_value :=
                        current_node^^.element_value^.field_values^ [1].value^.low_value;
                ELSE
                  clp$make_char_value (original_code_high, work_area,
                        current_node^^.element_value^.field_values^ [1].value^.high_value);
                IFEND;
                clp$make_char_value (substitute_code, work_area, current_node^^.element_value^.
                      field_values^ [2].value);
                current_node := ^current_node^^.link;
                j := j + 1;
              WHILEND;
            IFEND;
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$echoplex =
          result^.field_values^ [i].name := 'ECHOPLEX';
          clp$make_boolean_value (attributes^ [i].echoplex, clc$yes_no_boolean, work_area,
                result^.field_values^ [i].value);

        = ifc$end_line_character =
          result^.field_values^ [i].name := 'END_LINE_CHARACTER';
          clp$make_char_value (attributes^ [i].end_line_character, work_area, result^.field_values^ [i].
                value);

        = ifc$end_line_positioning =
          result^.field_values^ [i].name := 'END_LINE_POSITIONING';
          clp$make_keyword_value (end_line_positions [attributes^ [i].end_line_positioning],
                work_area, result^.field_values^ [i].value);

        = ifc$end_output_sequence =
          result^.field_values^ [i].name := 'END_OUTPUT_SEQUENCE';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_string_value (attributes^ [i].end_output_sequence.
                  value (1, attributes^ [i].end_output_sequence.size), work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$end_page_action =
          result^.field_values^ [i].name := 'END_PAGE_ACTION';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_keyword_value (end_page_actions [attributes^ [i].end_page_action],
                  work_area, result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$end_partial_character =
          result^.field_values^ [i].name := 'END_PARTIAL_CHARACTER';
          clp$make_char_value (attributes^ [i].end_partial_character, work_area,
                result^.field_values^ [i].value);

        = ifc$end_partial_positioning =
          result^.field_values^ [i].name := 'END_PARTIAL_POSITIONING';
          clp$make_keyword_value (end_partial_positions [attributes^ [i].end_partial_positioning],
                work_area, result^.field_values^ [i].value);

        = ifc$fold_line =
          result^.field_values^ [i].name := 'FOLD_LINE';
          clp$make_boolean_value (attributes^ [i].fold_line, clc$yes_no_boolean, work_area,
                result^.field_values^ [i].value);

        = ifc$form_feed_delay =
          result^.field_values^ [i].name := 'FORM_FEED_DELAY';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_integer_value (attributes^ [i].form_feed_delay, 10, FALSE, work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$form_feed_sequence =
          result^.field_values^ [i].name := 'FORM_FEED_SEQUENCE';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_string_value (attributes^ [i].form_feed_sequence.
                  value (1, attributes^ [i].form_feed_sequence.size), work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$function_key_class =
          result^.field_values^ [i].name := 'FUNCTION_KEY_CLASS';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            IF attributes^ [i].function_key_class^.value (1, attributes^ [i].function_key_class^.size) =
                  '' THEN
              clp$make_keyword_value ('NONE', work_area, result^.field_values^ [i].value);
            ELSE
              clp$make_string_value (attributes^ [i].function_key_class^.
                    value (1, attributes^ [i].function_key_class^.size), work_area,
                    result^.field_values^ [i].value);
            IFEND;
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$hold_page =
          result^.field_values^ [i].name := 'HOLD_PAGE';
          clp$make_boolean_value (attributes^ [i].hold_page, clc$yes_no_boolean, work_area,
                result^.field_values^ [i].value);

        = ifc$hold_page_over =
          result^.field_values^ [i].name := 'HOLD_PAGE_OVER';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_boolean_value (attributes^ [i].hold_page_over, clc$yes_no_boolean, work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$line_feed_delay =
          result^.field_values^ [i].name := 'LINE_FEED_DELAY';
          clp$make_integer_value (attributes^ [i].line_feed_delay, 10, FALSE, work_area,
                result^.field_values^ [i].value);

        = ifc$line_feed_sequence =
          result^.field_values^ [i].name := 'LINE_FEED_SEQUENCE';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_string_value (attributes^ [i].line_feed_sequence.
                  value (1, attributes^ [i].line_feed_sequence.size), work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$network_command_character =
          result^.field_values^ [i].name := 'NETWORK_COMMAND_CHARACTER';
          clp$make_char_value (attributes^ [i].network_command_character, work_area, result^.
                field_values^ [i].value);

        = ifc$page_length =
          result^.field_values^ [i].name := 'PAGE_LENGTH';
          clp$make_integer_value (attributes^ [i].page_length, 10, FALSE, work_area, result^.
                field_values^ [i].value);

        = ifc$page_width =
          result^.field_values^ [i].name := 'PAGE_WIDTH';
          clp$make_integer_value (attributes^ [i].page_width, 10, FALSE, work_area,
                result^.field_values^ [i].value);

        = ifc$parity =
          result^.field_values^ [i].name := 'PARITY';
          clp$make_keyword_value (parity_modes [attributes^ [i].parity], work_area,
                result^.field_values^ [i].value);

        = ifc$pause_break_character =
          result^.field_values^ [i].name := 'PAUSE_BREAK_CHARACTER';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_char_value (attributes^ [i].pause_break_character, work_area,
                  result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$status_action =
          result^.field_values^ [i].name := 'STATUS_ACTION';
          clp$make_keyword_value (status_actions [attributes^ [i].status_action],
                work_area, result^.field_values^ [i].value);

        = ifc$terminal_class =
          result^.field_values^ [i].name := 'TERMINAL_CLASS';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_keyword_value (terminal_classes [attributes^ [i].terminal_class],
                  work_area, result^.field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$terminal_model =
          IF connect_view_requested THEN
            connect_view := (attributes^ [i].terminal_model.size > STRLENGTH (pc_connect_)) AND
                  (attributes^ [i].terminal_model.value (1, STRLENGTH (pc_connect_)) = pc_connect_) AND
                  (attributes^ [i].terminal_model.value (STRLENGTH (pc_connect_) + 1) >= '2');
            IF NOT terminal_model_requested THEN
              result^.field_values^ [i].name := 'CONNECT_VIEW';
              clp$make_boolean_value (connect_view, clc$yes_no_boolean, work_area,
                    result^.field_values^ [i].value);
            IFEND;
          IFEND;

          IF terminal_model_requested THEN
            result^.field_values^ [i].name := 'TERMINAL_MODEL';
            IF attributes^ [i].terminal_model.value (1, attributes^ [i].terminal_model.size) = '' THEN
              clp$make_keyword_value ('NONE', work_area, result^.field_values^ [i].value);
            ELSE
              clp$make_name_value (attributes^ [i].terminal_model.
                    value (1, attributes^ [i].terminal_model.size), work_area, result^.field_values^ [i].
                    value);
            IFEND;
          IFEND;

        = ifc$terminal_name =
          result^.field_values^ [i].name := 'TERMINAL_NAME';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_trimmed_string_value (attributes^ [i].terminal_name^, work_area, result^.
                  field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        = ifc$terminate_break_character =
          result^.field_values^ [i].name := 'TERMINATE_BREAK';
          IF attributes^ [i].key <> ifc$null_terminal_attribute THEN
            clp$make_char_value (attributes^ [i].terminate_break_character, work_area, result^.
                  field_values^ [i].value);
          ELSEIF make_for_display THEN
            clp$make_application_value (attribute_undefined_message, work_area,
                  result^.field_values^ [i].value);
          ELSE
            clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
          IFEND;

        ELSE
          result^.field_values^ [i].name := 'Unknown Attribute #';
          clp$make_integer_value ($INTEGER (requested_attributes^ [i].key),
                10, FALSE, work_area, result^.field_values^ [i].value);
        CASEND;
      FOREND;
    IFEND;

    IF terminal_model_requested AND connect_view_requested THEN
      result^.field_values^ [UPPERBOUND (result^.field_values^) - $INTEGER (network_requested)].name :=
            'CONNECT_VIEW';
      clp$make_boolean_value (connect_view, clc$yes_no_boolean, work_area, result^.
            field_values^ [UPPERBOUND (result^.field_values^) - $INTEGER (network_requested)].value);
    IFEND;

    IF network_requested THEN
      ifp$get_network_identifier (network_identifier, status);
      IF (NOT status.normal) OR (network_identifier > ifc$max_network_identifier) THEN
        status.normal := TRUE;
        network_identifier := SUCC (ifc$max_network_identifier);
      IFEND;
      result^.field_values^ [UPPERBOUND (result^.field_values^)].name := 'NETWORK';
      clp$make_trimmed_string_value (network_identifiers [network_identifier], work_area,
            result^.field_values^ [UPPERBOUND (result^.field_values^)].value);
    IFEND;

    clp$sort_record_fields (result^.field_values^);

  PROCEND make_term_attr_record;
?? TITLE := 'make_term_conn_attr_record', EJECT ??

  PROCEDURE make_term_conn_attr_record
    (    make_for_display: boolean;
         terminal_file: ^fst$file_reference;
         options: clt$parameter_value;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    TYPE
      connection_attributes = set of ift$connection_attribute_keys;

    VAR
      input_editing_modes: [STATIC, READ, oss$job_paged_literal] array [ift$input_editing_mode] of
            string (11) := ['NORMAL', 'TRANSPARENT'],
      input_output_modes: [STATIC, READ, oss$job_paged_literal] array [ift$input_output_mode] of
            string (11) := ['UNSOLICITED', 'SOLICITED', 'FULL_DUPLEX'],
      transparent_character_modes: [STATIC, READ, oss$job_paged_literal] array [ift$trans_character_mode] of
            string (17) := ['NONE', 'TERMINATE', 'FORWARD', 'FORWARD_TERMINATE'],
      transparent_length_modes: [STATIC, READ, oss$job_paged_literal] array [ift$trans_length_mode] of
            string (13) := ['NONE', 'TERMINATE', 'FORWARD', 'FORWARD_EXACT'],
      transparent_protocol_modes: [STATIC, READ, oss$job_paged_literal] array [ift$trans_protocol_mode] of
            string (9) := ['NONE', 'TERMINATE', 'FORWARD'],
      transparent_timeout_modes: [STATIC, READ, oss$job_paged_literal] array [ift$trans_timeout_mode] of
            string (9) := ['NONE', 'TERMINATE', 'FORWARD'];

    VAR
      attribute_count: clt$list_size,
      attributes_for_file: boolean,
      attribute_key: ift$connection_attribute_keys,
      attribute_set: connection_attributes,
      attributes: ^ift$get_connection_attributes,
      current_node: ^^clt$data_value,
      file: clt$file,
      file_reference: ^fst$path,
      i: clt$list_size,
      j: integer,
      option: ^clt$data_value,
      requested_attributes: ^ift$get_connection_attributes;


    IF options.value^.kind = clc$keyword {ALL} THEN
      attribute_set := -$connection_attributes [] - $connection_attributes
            [ifc$null_connection_attribute, ifc$prompt_file_identifier];
    ELSE {clc$list}
      attribute_set := $connection_attributes [];
      option := options.value;
      WHILE option <> NIL DO
        get_connection_attribute_key (option^.element_value^.name_value, attribute_key);
        attribute_set := attribute_set + $connection_attributes [attribute_key];
        option := option^.link;
      WHILEND;
    IFEND;

    i := 0;
    FOR attribute_key := ifc$attention_character_action TO ifc$max_connection_key DO
      i := i + $INTEGER (attribute_key IN attribute_set);
    FOREND;

    PUSH attributes: [1 .. i];
    PUSH requested_attributes: [1 .. i];
    i := 0;

    FOR attribute_key := ifc$attention_character_action TO ifc$max_connection_key DO
      IF attribute_key IN attribute_set THEN
        i := i + 1;
        attributes^ [i].key := attribute_key;
      IFEND;
    FOREND;

    requested_attributes^ := attributes^;
    IF terminal_file = NIL THEN
      ifp$get_term_conn_defaults (clv$standard_files [clc$sf_command_file].path_handle_name, attributes^,
            status);
    ELSE
      clp$convert_string_to_file (terminal_file^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      ifp$get_term_conn_attributes (file.local_file_name, attributes^, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$make_record_value (UPPERBOUND (attributes^), work_area, result);
    FOR i := 1 TO UPPERBOUND (attributes^) DO
      CASE requested_attributes^ [i].key OF

      = ifc$attention_character_action =
        result^.field_values^ [i].name := 'ATTENTION_CHARACTER_ACTION';
        clp$make_integer_value (attributes^ [i].attention_character_action, 10, FALSE, work_area,
              result^.field_values^ [i].value);

      = ifc$break_key_action =
        result^.field_values^ [i].name := 'BREAK_KEY_ACTION';
        clp$make_integer_value (attributes^ [i].break_key_action, 10, FALSE, work_area,
              result^.field_values^ [i].value);

      = ifc$end_of_information =
        result^.field_values^ [i].name := 'END_OF_INFORMATION';
        clp$make_string_value (attributes^ [i].end_of_information.
              value (1, attributes^ [i].end_of_information.size), work_area, result^.field_values^ [i].value);

      = ifc$input_block_size =
        result^.field_values^ [i].name := 'INPUT_BLOCK_SIZE';
        clp$make_integer_value (attributes^ [i].input_block_size, 10, FALSE, work_area,
              result^.field_values^ [i].value);

      = ifc$input_editing_mode =
        result^.field_values^ [i].name := 'INPUT_EDITING_MODE';
        clp$make_keyword_value (input_editing_modes [attributes^ [i].input_editing_mode],
              work_area, result^.field_values^ [i].value);

      = ifc$input_output_mode =
        result^.field_values^ [i].name := 'INPUT_OUTPUT_MODE';
        clp$make_keyword_value (input_output_modes [attributes^ [i].input_output_mode],
              work_area, result^.field_values^ [i].value);

      = ifc$input_timeout =
        result^.field_values^ [i].name := 'INPUT_TIMEOUT';
        clp$make_boolean_value (attributes^ [i].input_timeout, clc$yes_no_boolean, work_area,
              result^.field_values^ [i].value);

      = ifc$input_timeout_length =
        result^.field_values^ [i].name := 'INPUT_TIMEOUT_LENGTH';
        clp$make_integer_value (attributes^ [i].input_timeout_length, 10, FALSE, work_area,
              result^.field_values^ [i].value);

      = ifc$input_timeout_purge =
        result^.field_values^ [i].name := 'INPUT_TIMEOUT_PURGE';
        clp$make_boolean_value (attributes^ [i].input_timeout_purge, clc$yes_no_boolean, work_area,
              result^.field_values^ [i].value);

      = ifc$partial_char_forwarding =
        result^.field_values^ [i].name := 'PARTIAL_CHARACTER_FORWARDING';
        clp$make_boolean_value (attributes^ [i].partial_character_forwarding, clc$yes_no_boolean, work_area,
              result^.field_values^ [i].value);

      = ifc$prompt_file =
        result^.field_values^ [i].name := 'PROMPT_FILE';
        PUSH file_reference;
        clp$get_path_name (attributes^ [i].prompt_file, osc$full_message_level, file_reference^);
        clp$make_file_value (file_reference^, work_area, result^.field_values^ [i].value);

      = ifc$prompt_string =
        result^.field_values^ [i].name := 'PROMPT_STRING';
        clp$make_string_value (attributes^ [i].prompt_string.value (1, attributes^ [i].prompt_string.size),
              work_area, result^.field_values^ [i].value);

      = ifc$store_backspace_character =
        result^.field_values^ [i].name := 'STORE_BACKSPACE_CHARACTER';
        clp$make_boolean_value (attributes^ [i].store_backspace_character, clc$yes_no_boolean, work_area,
              result^.field_values^ [i].value);

      = ifc$store_nuls_dels =
        result^.field_values^ [i].name := 'STORE_NULS_DELS';
        clp$make_boolean_value (attributes^ [i].store_nuls_dels, clc$yes_no_boolean, work_area,
              result^.field_values^ [i].value);

      = ifc$trans_character_mode =
        result^.field_values^ [i].name := 'TRANSPARENT_CHARACTER_MODE';
        clp$make_keyword_value (transparent_character_modes [attributes^ [i].trans_character_mode], work_area,
              result^.field_values^ [i].value);

      = ifc$trans_length_mode =
        result^.field_values^ [i].name := 'TRANSPARENT_LENGTH_MODE';
        clp$make_keyword_value (transparent_length_modes [attributes^ [i].trans_length_mode],
              work_area, result^.field_values^ [i].value);

      = ifc$trans_message_length =
        result^.field_values^ [i].name := 'TRANSPARENT_MESSAGE_LENGTH';
        clp$make_integer_value (attributes^ [i].trans_message_length, 10, FALSE, work_area,
              result^.field_values^ [i].value);

      = ifc$trans_timeout_mode =
        result^.field_values^ [i].name := 'TRANSPARENT_TIMEOUT_MODE';
        clp$make_keyword_value (transparent_timeout_modes [attributes^ [i].trans_timeout_mode],
              work_area, result^.field_values^ [i].value);

      = ifc$trans_forward_character =
        result^.field_values^ [i].name := 'TRANSPARENT_FORWARD_CHARACTER';
        current_node := ^result^.field_values^ [i].value;
        FOR j := 1 TO attributes^ [i].trans_forward_character.size DO
          clp$make_list_value (work_area, current_node^);
          clp$make_char_value (attributes^ [i].trans_forward_character.value (j), work_area,
                current_node^^.element_value);
          current_node := ^current_node^^.link;
        FOREND;

      = ifc$trans_terminate_character =
        result^.field_values^ [i].name := 'TRANSPARENT_TERMINATE_CHARACTER';
        clp$make_string_value (attributes^ [i].trans_terminate_character.value (1), work_area,
              result^.field_values^ [i].value);
        current_node := ^result^.field_values^ [i].value;
        FOR j := 1 TO attributes^ [i].trans_terminate_character.size DO
          clp$make_list_value (work_area, current_node^);
          clp$make_char_value (attributes^ [i].trans_terminate_character.value (j), work_area,
                current_node^^.element_value);
          current_node := ^current_node^^.link;
        FOREND;

      = ifc$trans_protocol_mode =
        result^.field_values^ [i].name := 'TRANSPARENT_PROTOCOL_MODE';
        IF attributes^ [i].key <> ifc$null_connection_attribute THEN
          clp$make_keyword_value (transparent_protocol_modes [attributes^ [i].trans_protocol_mode], work_area,
                result^.field_values^ [i].value);
        ELSEIF make_for_display THEN
          clp$make_application_value (attribute_undefined_message, work_area, result^.field_values^ [i].
                value);
        ELSE
          clp$make_unspecified_value (work_area, result^.field_values^ [i].value);
        IFEND;

      ELSE
        result^.field_values^ [i].name := 'Unknown Attribute #';
        clp$make_integer_value ($INTEGER (requested_attributes^ [i].key),
              10, FALSE, work_area, result^.field_values^ [i].value);
      CASEND;
    FOREND;

    clp$sort_record_fields (result^.field_values^);

  PROCEND make_term_conn_attr_record;

MODEND ifm$interactive_commands;
