*copyc OSD$DEFAULT_PRAGMATS
MODULE iim$change_term_conn_defaults;

{ PURPOSE:  This module provides the ring 2 interface to change the
{           default connection attributes for a dual state task.
{           Consequently, subsequent file creations will employ the
{           new attribute values, but previously created files will
{           not be affected.
{
{  DESIGN:  The new attribute values are validated and are then used
{           to replace corresponding values in an IF attributes table
{           which resides in task shared memory.
{
{           For dual state connections, attribute validation consists
{           of verifying that the attribute key is known and that the
{           value is within the valid range for the attribute.  Once
{           this verification is completed for each input attribute
{           the new values replace their corresponding attributes in
{           a task-shared table of attributes pointed at by the
{           iiv$terminal_request_ptr.
{
?? TITLE := 'MODULE iim$change_term_conn_defaults' ??

?? PUSH (LISTEXT := ON) ??
*copyc AMP$FETCH
*copyc CLP$GET_ULTIMATE_CONNECTION
*copyc IFE$ERROR_CODES
*copyc iik$keypoints
*copyc IIT$CONNECTION_DESCRIPTION
*copyc IIP$ALLOCATE_QUEUE_ENTRY
*copyc IIP$BUILD_TERM_CONN_ATTR_ARRAY
*copyc IIV$INTERACTIVE_TERMINATED
*copyc IIV$INT_TASK_OPEN_FILE_COUNT
*copyc JMP$SYSTEM_JOB
*copyc OST$STATUS
*copyc OSP$APPEND_STATUS_INTEGER
*copyc OSP$APPEND_STATUS_PARAMETER
*copyc OSP$SET_STATUS_ABNORMAL
*copyc PMP$GET_JOB_MODE
*copyc RMP$GET_DEVICE_CLASS
?? POP ??

?? NEWTITLE := 'PROCEDURE iip$change_term_conn_defaults', EJECT ??

  PROCEDURE [XDCL, #GATE] iip$change_term_conn_defaults (
        connection_attributes: ift$connection_attributes;
    VAR status: ost$status);

    VAR
      device_assigned: boolean,
      device_class: rmt$device_class,
      fetch_attributes: array [1 .. 1] of amt$fetch_item,
      i: integer,
      j: ift$connection_attribute_keys,
      job_mode: jmt$job_mode,
      k: integer,
      local_status: ost$status,
      replace_attributes: iit$connection_attributes,
      set_of_input_editing_modes: iit$set_of_input_editing_modes,
      set_of_input_output_modes: iit$set_of_input_output_modes,
      set_of_terminal_attribute_keys: iit$set_of_term_conn_attr_keys,
      set_of_trans_char_modes: iit$set_of_trans_char_modes,
      set_of_trans_length_modes: iit$set_of_trans_length_modes,
      set_of_trans_protocol_modes: iit$set_of_trans_protocol_modes,
      set_of_trans_timeout_modes: iit$set_of_trans_timeout_modes,
      terminal_request_attributes: iit$connection_attributes,
      terminal_request_descriptor: iit$queue_entry_descriptor,
      ultimate_prompt_file: amt$local_file_name;

    status.normal := TRUE;
    #KEYPOINT (osk$entry, 0, iik$change_term_conn_defaults);

  { Validate the connection attribute keys.

    set_of_terminal_attribute_keys := - $iit$set_of_term_conn_attr_keys [];
    FOR i := LOWERBOUND (connection_attributes) TO UPPERBOUND (connection_attributes) DO
      IF NOT (connection_attributes [i].key IN set_of_terminal_attribute_keys) THEN
        osp$set_status_abnormal (ifc$interactive_facility_id,
              ife$unknown_attribute_key, '', status);
        k := ORD (connection_attributes [i].key);
        osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
              FALSE, status);
        osp$append_status_parameter (osc$status_parameter_delimiter,
          'IFP$CHANGE_TERM_CONN_ATTRIBUTES', status);
        RETURN;
      IFEND;
    FOREND;

  { Validate the attribute values.

    FOR i := LOWERBOUND (connection_attributes) TO UPPERBOUND
          (connection_attributes) DO

      CASE connection_attributes [i].key OF

      = ifc$attention_character_action =

        k := connection_attributes [i].attention_character_action;
        IF ((k < LOWERVALUE (ift$attention_character_action)) OR (k >
              UPPERVALUE (ift$attention_character_action))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$attention_character_action, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$attention_character_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$attention_character_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$break_key_action =

        k := connection_attributes [i].break_key_action;
        IF ((k < LOWERVALUE (ift$break_key_action)) OR (k >
              UPPERVALUE (ift$break_key_action))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$break_key_action, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$break_key_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$break_key_action);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$end_of_information =

        k := connection_attributes [i].end_of_information.size;
        IF ((k < LOWERVALUE (ift$end_of_information_size)) OR (k > UPPERVALUE
              (ift$end_of_information_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$end_of_information_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$end_of_information_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$end_of_information_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$input_block_size =

        k := connection_attributes [i].input_block_size;
        IF ((k < LOWERVALUE (ift$input_block_size)) OR (k > UPPERVALUE
              (ift$input_block_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_block_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$input_block_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$input_block_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$input_editing_mode =

        set_of_input_editing_modes := - $iit$set_of_input_editing_modes [];
        IF NOT (connection_attributes [i].input_editing_mode IN set_of_input_editing_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_input_editing_mode, '', status);
          k := ORD (connection_attributes [i].input_editing_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$input_output_mode =

        set_of_input_output_modes := - $iit$set_of_input_output_modes [];
        IF NOT (connection_attributes [i].input_output_mode IN set_of_input_output_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_input_output_mode, '', status);
          k := ORD (connection_attributes [i].input_output_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$input_timeout =

        IF ((connection_attributes [i].input_timeout < LOWERVALUE
              (boolean)) OR (connection_attributes [i].input_timeout >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_timeout, 'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$input_timeout_length =

        k := connection_attributes [i].input_timeout_length;
        IF ((k < LOWERVALUE (ift$input_timeout_length)) OR (k > UPPERVALUE
              (ift$input_timeout_length))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_timeout_length, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$input_timeout_length);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$input_timeout_length);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$input_timeout_purge =

        IF ((connection_attributes [i].input_timeout_purge < LOWERVALUE
              (boolean)) OR (connection_attributes [i].input_timeout_purge >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$input_timeout_purge, 'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$partial_char_forwarding =

        IF ((connection_attributes [i].partial_character_forwarding < LOWERVALUE
              (boolean)) OR (connection_attributes [i].partial_character_forwarding >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$partial_char_forwarding, 'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$prompt_file =

        clp$get_ultimate_connection (connection_attributes [i].prompt_file, ultimate_prompt_file, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

{ Verify that the file is assigned to a terminal device.

        rmp$get_device_class (ultimate_prompt_file, device_assigned, device_class, local_status);
        IF NOT local_status.normal THEN
          status := local_status;
          RETURN;
        ELSE
          IF NOT device_assigned THEN
            osp$set_status_abnormal (ifc$interactive_facility_id,
                  ife$prompt_file_name_not_found, ultimate_prompt_file, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
              'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
            RETURN;
          ELSEIF device_class <> rmc$terminal_device THEN
            osp$set_status_abnormal (ifc$interactive_facility_id,
                  ife$prompt_file_name_not_term, ultimate_prompt_file, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
              'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
            RETURN;
          IFEND;
        IFEND;

      = ifc$prompt_file_identifier =

{ Get the file_name for the file_id.

{ The following code is no-op'ed until BAM provides a way to obtain
{ the local_file_name given the file_id.

{       fetch_attributes [1].key := amc$local_file_name;
{       amp$fetch (connection_attributes [i].prompt_file_identifier, fetch_attributes,
{             local_status);
{       IF NOT local_status.normal THEN
{         status := local_status;
{         RETURN;
{       IFEND;
{
{ Verify that the file is assigned to a terminal device.
{
{       rmp$get_device_class (fetch_attributes [1].file_name^.local_file_name,
{             device_assigned, device_class, local_status);
{       IF NOT local_status.normal THEN
{         status := local_status;
{         RETURN;
{       ELSE
{         IF NOT device_assigned THEN
{           osp$set_status_abnormal (ifc$interactive_facility_id,
{                 ife$prompt_file_id_not_found, fetch_attributes [1].
{                 file_name^.local_file_name, status);
{           osp$append_status_parameter (osc$status_parameter_delimiter,
{             'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
{           RETURN;
{         ELSEIF device_class <> rmc$terminal_device THEN
{           osp$set_status_abnormal (ifc$interactive_facility_id,
{                 ife$prompt_file_id_not_term, fetch_attributes [1].file_name^.
{                 local_file_name, status);
{           osp$append_status_parameter (osc$status_parameter_delimiter,
{             'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
{           RETURN;
{         IFEND;
{       IFEND;

      = ifc$prompt_string =

        k := connection_attributes [i].prompt_string.size;
        IF ((k < LOWERVALUE (ift$prompt_string_size)) OR (k > UPPERVALUE
              (ift$prompt_string_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$prompt_string_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$prompt_string_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$prompt_string_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$store_backspace_character =

        IF ((connection_attributes [i].store_backspace_character < LOWERVALUE
              (boolean)) OR (connection_attributes [i].store_backspace_character >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$store_backspace_character, 'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$store_nuls_dels =

        IF ((connection_attributes [i].store_nuls_dels < LOWERVALUE
              (boolean)) OR (connection_attributes [i].store_nuls_dels >
              UPPERVALUE (boolean))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$store_nuls_dels, 'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$trans_character_mode =

        set_of_trans_char_modes := - $iit$set_of_trans_char_modes [];
        IF NOT (connection_attributes [i].trans_character_mode IN set_of_trans_char_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_char_mode, '', status);
          k := ORD (connection_attributes [i].trans_character_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$trans_length_mode =

        set_of_trans_length_modes := - $iit$set_of_trans_length_modes [];
        IF NOT (connection_attributes [i].trans_length_mode IN set_of_trans_length_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_length_mode, '', status);
          k := ORD (connection_attributes [i].trans_length_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$trans_timeout_mode =

        set_of_trans_timeout_modes := - $iit$set_of_trans_timeout_modes [];
        IF NOT (connection_attributes [i].trans_timeout_mode IN set_of_trans_timeout_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_timeout_mode, '', status);
          k := ORD (connection_attributes [i].trans_timeout_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$trans_forward_character =

        k := connection_attributes [i].trans_forward_character.size;
        IF ((k < LOWERVALUE (ift$trans_fwd_char_size)) OR (k > UPPERVALUE
              (ift$trans_fwd_char_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$trans_fwd_character_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$trans_fwd_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$trans_fwd_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$trans_message_length =

        k := connection_attributes [i].trans_message_length;
        IF ((k < LOWERVALUE (ift$trans_message_length)) OR (k > UPPERVALUE
              (ift$trans_message_length))) THEN
          IF k <> 0 THEN
            osp$set_status_abnormal (ifc$interactive_facility_id,
                  ife$trans_message_length, '', status);
            osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                  FALSE, status);
            k := LOWERVALUE (ift$trans_message_length);
            osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                  FALSE, status);
            k := UPPERVALUE (ift$trans_message_length);
            osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                  FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
              'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
            RETURN;
          IFEND;
        IFEND;

      = ifc$trans_terminate_character =

        k := connection_attributes [i].trans_terminate_character.size;
        IF ((k < LOWERVALUE (ift$trans_term_char_size)) OR (k > UPPERVALUE
              (ift$trans_term_char_size))) THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$trans_term_character_size, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := LOWERVALUE (ift$trans_term_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          k := UPPERVALUE (ift$trans_term_char_size);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      = ifc$trans_protocol_mode =

        set_of_trans_protocol_modes := - $iit$set_of_trans_protocol_modes [];
        IF NOT (connection_attributes [i].trans_protocol_mode IN set_of_trans_protocol_modes)
              THEN
          osp$set_status_abnormal (ifc$interactive_facility_id,
                ife$unknown_trans_protocol_mode, '', status);
          k := ORD (connection_attributes [i].trans_protocol_mode);
          osp$append_status_integer (osc$status_parameter_delimiter, k, 10,
                FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter,
            'IFP$CHANGE_TERM_CONN_DEFAULTS', status);
          RETURN;
        IFEND;

      ELSE
      CASEND;

    FOREND; { validate each input attribute value }

  { Initialize the terminal request attributes.

    IF iiv$terminal_request_ptr = NIL THEN
      terminal_request_attributes := iiv$init_undefined_attributes;
    ELSE
      terminal_request_attributes := iiv$terminal_request_ptr^;
    IFEND;

  { Replace the attributes specified on the IFP$CHANGE_TERM_CONN_DEFAULTS in the
  { terminal request table.

    FOR i := LOWERBOUND (connection_attributes) TO UPPERBOUND (connection_attributes) DO
      CASE connection_attributes [i].key OF

      = ifc$attention_character_action =
        terminal_request_attributes.attention_character_action.value := connection_attributes [i].
              attention_character_action;
        terminal_request_attributes.attention_character_action.source := ifc$change_term_conn_dflt_req;

      = ifc$break_key_action =
        terminal_request_attributes.break_key_action.value := connection_attributes [i].
              break_key_action;
        terminal_request_attributes.break_key_action.source := ifc$change_term_conn_dflt_req;

      = ifc$end_of_information =
        terminal_request_attributes.end_of_information.value := connection_attributes [i].
              end_of_information;
        terminal_request_attributes.end_of_information.source := ifc$change_term_conn_dflt_req;

      = ifc$input_block_size =
        terminal_request_attributes.input_block_size.value := connection_attributes [i].
              input_block_size;
        terminal_request_attributes.input_block_size.source := ifc$change_term_conn_dflt_req;

      = ifc$input_editing_mode =
        terminal_request_attributes.input_editing_mode.value := connection_attributes [i].
              input_editing_mode;
        terminal_request_attributes.input_editing_mode.source := ifc$change_term_conn_dflt_req;

      = ifc$input_output_mode =
        terminal_request_attributes.input_output_mode.value := connection_attributes [i].
              input_output_mode;
        terminal_request_attributes.input_output_mode.source := ifc$change_term_conn_dflt_req;

      = ifc$input_timeout =
        terminal_request_attributes.input_timeout.value := connection_attributes [i].
              input_timeout;
        terminal_request_attributes.input_timeout.source := ifc$change_term_conn_dflt_req;

      = ifc$input_timeout_length =
        terminal_request_attributes.input_timeout_length.value := connection_attributes [i].
              input_timeout_length;
        terminal_request_attributes.input_timeout_length.source := ifc$change_term_conn_dflt_req;

      = ifc$input_timeout_purge =
        terminal_request_attributes.input_timeout_purge.value := connection_attributes [i].
              input_timeout_purge;
        terminal_request_attributes.input_timeout_purge.source := ifc$change_term_conn_dflt_req;

      = ifc$partial_char_forwarding =
        terminal_request_attributes.partial_char_forwarding.value := connection_attributes [i].
              partial_character_forwarding;
        terminal_request_attributes.partial_char_forwarding.source := ifc$change_term_conn_dflt_req;

      = ifc$prompt_file =
        terminal_request_attributes.prompt_file.value := connection_attributes [i].
              prompt_file;
        terminal_request_attributes.prompt_file.source := ifc$change_term_conn_dflt_req;

      = ifc$prompt_file_identifier =
        terminal_request_attributes.prompt_file_identifier.value := connection_attributes [i].
              prompt_file_identifier;
        terminal_request_attributes.prompt_file_identifier.source := ifc$change_term_conn_dflt_req;

      = ifc$prompt_string =
        terminal_request_attributes.prompt_string.value := connection_attributes [i].
              prompt_string;
        terminal_request_attributes.prompt_string.source := ifc$change_term_conn_dflt_req;

      = ifc$store_backspace_character =
        terminal_request_attributes.store_backspace_character.value := connection_attributes [i].
              store_backspace_character;
        terminal_request_attributes.store_backspace_character.source := ifc$change_term_conn_dflt_req;

      = ifc$store_nuls_dels =
        terminal_request_attributes.store_nuls_dels.value := connection_attributes [i].
              store_nuls_dels;
        terminal_request_attributes.store_nuls_dels.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_character_mode =
        terminal_request_attributes.trans_character_mode.value := connection_attributes [i].
              trans_character_mode;
        terminal_request_attributes.trans_character_mode.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_forward_character =
        terminal_request_attributes.trans_forward_character.value := connection_attributes [i].
              trans_forward_character;
        terminal_request_attributes.trans_forward_character.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_length_mode =
        terminal_request_attributes.trans_length_mode.value := connection_attributes [i].
              trans_length_mode;
        terminal_request_attributes.trans_length_mode.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_timeout_mode =
        terminal_request_attributes.trans_timeout_mode.value := connection_attributes [i].
              trans_timeout_mode;
        terminal_request_attributes.trans_timeout_mode.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_message_length =
        terminal_request_attributes.trans_message_length.value := connection_attributes [i].
              trans_message_length;
        terminal_request_attributes.trans_message_length.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_terminate_character =
        terminal_request_attributes.trans_terminate_character.value := connection_attributes [i].
              trans_terminate_character;
        terminal_request_attributes.trans_terminate_character.source := ifc$change_term_conn_dflt_req;

      = ifc$trans_protocol_mode =
        terminal_request_attributes.trans_protocol_mode.value := connection_attributes [i].
              trans_protocol_mode;
        terminal_request_attributes.trans_protocol_mode.source := ifc$change_term_conn_dflt_req;

      ELSE
      CASEND;
    FOREND;

{ Allocate a terminal request table if the task doesn't have one.

    IF iiv$terminal_request_ptr = NIL THEN
      iip$allocate_queue_entry (iic$terminal_request,
            terminal_request_descriptor, local_status);
      iiv$terminal_request_ptr := terminal_request_descriptor.terminal_request_ptr;
    IFEND;

  { Replace the terminal request attributes in the terminal request table.

    iiv$terminal_request_ptr^ := terminal_request_attributes;

    #KEYPOINT (osk$exit, 0, iik$change_term_conn_defaults);

  PROCEND iip$change_term_conn_defaults;

MODEND iim$change_term_conn_defaults;
