*copyc OSD$DEFAULT_PRAGMATS
MODULE iim$set_default_attributes;

{ PURPOSE:  The procedure in this module is designed to extract and use the
{           attribute values from a CTRL/TCD/R message, or CTRL/CCD/N in
{           the case of NAM/CDCNET, to initialize the
{           nam_os_default_attributes, terminal_attributes,
{           active_term_char_values, and term_char_values fields of an
{           IIT$CONNECTION_DESCRIPTION record passed as a formal input
{           parameter.  Its only caller, IIM$REQUEST_DEFAULT_ATTRIBUTES, is
{           only called for dual state connections and only during LOGIN
{           and when a SETTA changes the terminal class.
{
{  DESIGN:  The CTRL/TCD/R, or CTRL/CCD/N, is an upline supervisory message
{           sent from NAM in response to the request for the terminal
{           characteristics, CTRL/RTC/R or CTRL/RCC/R, made by
{           IIM$REQUEST_DEFAULT_ATTRIBUTES.  It consists of a message
{           header followed by either an array of FN/FV pairs from CCP or
{           an array of AN/AV's from CDCNET.  Each field number and field
{           value (FN/FV) pair corresponds to a unique terminal
{           characteristic and its value.  An AN/AV consists of an octet,
{           which is an 8-bit value, to indicate the attribute number and
{           at least one octet for the value of the attribute; in the case
{           where the attribute value spans more than one octet, the first
{           bit of the attribute number octet is set, otherwise it is 0.
{
{           Extraneous zeroes added to the CTRL/TCD/R or CTRL/CCD/N message
{           by MLI are stripped off by calling IIP$CONVERT_UPLINE_TERM_CHAR
{           and attribute numbers in the resultant message are used for the
{           initialization.
{
{           Note that NAM/CDCNET does not return the pause break character,
{           terminate break character, or terminal class attribute values
{           so these attributes are initialized with constant values:
{                 PBC = '%',          TBC = '%',          TC = 3.
{
{           Note that there is a one-to-one correspondence between many of
{           the field_numbers and terminal/connection-attributes, for
{           example, 28(16) = Network_Control_Character and 31(16) =
{           Echoplex.  But other terminal/connection-attributes are defined
{           by multiple terminal characteristics.  For example,
{           Character_Flow_Control is set according to the values for
{           attribute numbers 43(16) and 44(16).
{
?? TITLE := 'MODULE iim$set_default_attributes' ??

?? PUSH (LISTEXT := ON) ??
*copyc IIP$CLEAR_LOCK
*copyc IIT$CONNECTION_DESCRIPTION
*copyc IIP$CONVERT_UPLINE_TERM_CHAR
*copyc IIP$SET_LOCK
*copyc iit$vt_attributes
*copyc iit$vt_attribute_descriptions
*copyc iit$vt_attribute_kinds
*copyc IIV$INTERACTIVE_TERMINATED
*copyc OST$STATUS
*copyc PMP$LOG
?? POP ??

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

  PROCEDURE [XDCL] iip$set_default_attributes (input_super_message_pointer:
        ^iit$input_supervisory_message;
        cdp: ^iit$connection_description;
    VAR status: ost$status);

    VAR
      delay: 0 .. 999,
      field_value: iit$field_value,
      field_values: iit$term_char_string,
      field_value2: iit$field_value,
      i: integer,
      index: integer,
      limit: integer,
      local_status: ost$status,
      nam_os_defaults: ^iit$connection_attributes,
      number: 0 .. 255,
      octets: array [1 .. iic$vt_max_output_mess_length] of iit$field_value,
      terminal_attributes: ^iit$terminal_attributes,
      term_char_definitions_message: iit$input_supervisory_message,
      vt_attribute: iit$field_number,
      xpt_count_value: 0 .. 32767;

      iip$set_lock (cdp^.lock, osc$wait, local_status);
      nam_os_defaults := ^cdp^.nam_os_default_attributes;
      terminal_attributes := ^cdp^.terminal_attributes;

  { Convert the terminal characteristics definitions message from C170 format
  { to C180 format.

    iip$convert_upline_term_char (#LOC (input_super_message_pointer^), #LOC
          (term_char_definitions_message), (input_super_message_pointer^.
          header.text_length - 2) * 2);

    IF iiv$cdcnet_connection THEN
      field_values := iiv$skeleton_term_char_string;
      octets := term_char_definitions_message.cdcnet_term_char_defines.array_of_octets;
      limit := term_char_definitions_message.header.text_length - 2;
      index := 1;

      REPEAT

{ Extract the attribute-number octet.  Determine the number
{ of octets which comprise the attribute-value and the array
{ index of the first octet of the attribute-value.

        vt_attribute := octets [index];
        IF octets [index] >= 80(16) THEN
      { This is a multiple octet. }
          vt_attribute := octets [index] - 80(16);
          number := octets [index + 1];
          index := index + 2;
        ELSE
          number := 1;
          index := index + 1;
        IFEND;

{ Initialize the field values of an IIV$SKELETON_TERM_CHAR_STRING array,
{ and the terminal and connection attributes not in such an array.

        CASE vt_attribute OF

        = ORD (iic$vt_break_key_action) =
          nam_os_defaults^.break_key_action.value := octets [index];
          field_values [iic$key_user_break_1].field_value := octets [index];

        = ORD (iic$vt_input_editing_mode) =
          field_values [iic$key_trans_input_mode].field_value := octets [index];

        = ORD (iic$vt_input_output_mode) =
          CASE octets [index] OF
          = ORD (ifc$unsolicited_output) =
            field_values [iic$key_full_duplex].field_value := 0;
            field_values [iic$key_solicited_mode].field_value := 0;
          = ORD (ifc$solicited) =
            field_values [iic$key_full_duplex].field_value := 0;
            field_values [iic$key_solicited_mode].field_value := 1;
          = ORD (ifc$full_duplex) =
            field_values [iic$key_full_duplex].field_value := 1;
            field_values [iic$key_solicited_mode].field_value := 0;
          ELSE
          CASEND;

        = ORD (iic$vt_partial_char_forwarding) =
          IF octets [index] = 0 THEN
            field_values [iic$key_input_device].field_value := 0;
          ELSEIF octets [index] = 1 THEN
            field_values [iic$key_input_device].field_value := 2;
          IFEND;

        = ORD (iic$vt_store_backspace_char) =
          field_values [iic$key_special_editing].field_value := octets [index];

        = ORD (iic$vt_store_nuls_dels) =
          field_values [iic$key_full_ascii].field_value := octets [index];

        = ORD (iic$vt_trans_character_mode) =
          CASE octets [index] OF
          = ORD (ifc$no_trans_char) =
            field_values [iic$key_trans_delim_char_select].field_value := 0;
          = ORD (ifc$trans_char_terminate) =
            field_values [iic$key_trans_delim_char_select].field_value := 1;
            field_values [iic$key_trans_input_type].field_value := 0;
          = ORD (ifc$trans_char_forward), ORD (ifc$trans_char_fwd_terminate) =
            field_values [iic$key_trans_delim_char_select].field_value := 1;
            field_values [iic$key_trans_input_type].field_value := 1;
          ELSE
          CASEND;

        = ORD (iic$vt_trans_forward_character) =
          field_values [iic$key_trans_delim_character].field_value := octets [index];

        = ORD (iic$vt_trans_term_character) =
          field_values [iic$key_trans_mode_delim_char].field_value := octets [index];

        = ORD (iic$vt_trans_timeout_mode) =
          CASE octets [index] OF
          = ORD (ifc$no_trans_timeout) =
            field_values [iic$key_trans_delim_timeout].field_value := 0;
          = ORD (ifc$trans_timeout_terminate) =
            field_values [iic$key_trans_delim_timeout].field_value := 1;
            field_values [iic$key_trans_mode_delim_lock].field_value := 0;
          = ORD (ifc$trans_timeout_forward) =
            field_values [iic$key_trans_input_type].field_value := 1;
            field_values [iic$key_trans_delim_timeout].field_value := 1;
            field_values [iic$key_trans_mode_delim_lock].field_value := 1;
          ELSE
          CASEND;

        = ORD (iic$vt_trans_length_mode) =
          CASE octets [index] OF
          = ORD (ifc$no_trans_len) =
            field_values [iic$key_trans_delim_count_most].field_value := 0;
            field_values [iic$key_trans_delim_count_least].field_value := 0;
          = ORD (ifc$trans_len_terminate) =
            field_values [iic$key_trans_input_type].field_value := 0;
          = ORD (ifc$trans_len_forward), ORD (ifc$trans_len_forward_exact) =
            field_values [iic$key_trans_input_type].field_value := 1;
          ELSE
          CASEND;

        = ORD (iic$vt_trans_message_length) =
          IF number = 2 THEN
            field_values [iic$key_trans_delim_count_most].field_value := octets [index];
            field_values [iic$key_trans_delim_count_least].field_value := octets [index + 1];
          ELSEIF number = 1 THEN
            field_values [iic$key_trans_delim_count_most].field_value := 0;
            field_values [iic$key_trans_delim_count_least].field_value := octets [index];
          IFEND;

        = ORD (iic$vt_trans_protocol_mode) =
          CASE octets [index] OF
          = ORD (ifc$no_trans_protocol) =
            nam_os_defaults^.trans_timeout_mode.value := ifc$no_trans_timeout;
          = ORD (ifc$trans_protocol_terminate) =
            nam_os_defaults^.trans_timeout_mode.value :=
              ifc$trans_timeout_terminate;
          = ORD (ifc$trans_protocol_forward) =
            nam_os_defaults^.trans_timeout_mode.value :=
              ifc$trans_timeout_forward;
          ELSE
          CASEND;

        = ORD (iic$vt_page_width) =
          field_values [iic$key_page_width].field_value := octets [index];

        = ORD (iic$vt_page_length) =
          field_values [iic$key_page_length].field_value := octets [index];

        = ORD (iic$vt_cancel_line_character) =
          field_values [iic$key_cancel_line_character].field_value := octets [index];

        = ORD (iic$vt_backspace_character) =
          field_values [iic$key_backspace_character].field_value := octets [index];

        = ORD (iic$vt_carriage_return_delay) =
          IF number > 1 THEN
            delay := octets [index] * 100;
            delay := (delay + octets [index + 1]) DIV 4;
            field_values [iic$key_cr_delay_count].field_value := delay;
          ELSE
            field_values [iic$key_cr_delay_count].field_value := octets [index] DIV 4;
          IFEND;

        = ORD (iic$vt_line_feed_delay) =
          IF number > 1 THEN
            delay := octets [index] * 100;
            delay := (delay + octets [index + 1]) DIV 4;
            field_values [iic$key_lf_delay_count].field_value := delay;
          ELSE
            field_values [iic$key_lf_delay_count].field_value := octets [index] DIV 4;
          IFEND;

        = ORD (iic$vt_echoplex) =
          field_values [iic$key_echoplex].field_value := octets [index];

        = ORD (iic$vt_hold_page) =
          field_values [iic$key_hold_page].field_value := octets [index];

        = ORD (iic$vt_parity) =
          CASE octets [index] OF
          = 0, 1 =
            field_values [iic$key_parity].field_value := 0;
          = 2 =
            field_values [iic$key_parity].field_value := 2;
          = 3 =
            field_values [iic$key_parity].field_value := 1;
          = 4 =
            field_values [iic$key_parity].field_value := 3;
          ELSE
          CASEND;

        = ORD (iic$vt_network_command_char) =
          field_values [iic$key_network_cmd_character].field_value := octets [index];

        = ORD (iic$vt_end_partial_character) =
          field_values [iic$key_end_partial_character].field_value := octets [index];

        = ORD (iic$vt_end_partial_positioning) =
          field_values [iic$key_end_partial_positioning].field_value := octets [index];

        = ORD (iic$vt_end_line_character) =
          field_values [iic$key_end_line_character].field_value := octets [index];

        = ORD (iic$vt_end_line_positioning) =
          field_values [iic$key_end_line_positioning].field_value := octets [index];

        = ORD (iic$vt_character_flow_control) =
          field_values [iic$key_input_flow_control].field_value := octets [index];
          field_values [iic$key_output_flow_control].field_value := octets [index];

        = ORD (iic$vt_status_action) =
          IF octets [index] = 2 THEN
            field_values [iic$key_lockout_unsolicited_msg].field_value := 1;
          ELSE
            field_values [iic$key_lockout_unsolicited_msg].field_value := octets [index];
          IFEND;

        = ORD (iic$vt_end_output_sequence) =
          IF number <> 0 THEN
            field_values [iic$key_pacer_prompting].field_value := octets [index];
            FOR i := 0 TO (number - 1) DO
              terminal_attributes^.end_output_sequence.value (i + 1, 1) := CHR (octets [index + i]);
            FOREND;
          ELSE
            field_values [iic$key_pacer_prompting].field_value := 0;
            terminal_attributes^.end_output_sequence.value := '';
          IFEND;
          terminal_attributes^.end_output_sequence.size := number;

        = ORD (iic$vt_fold_line) =
          field_values [iic$key_output_device].field_value := octets [index];

        = ORD (iic$vt_attention_char_action) =
          nam_os_defaults^.attention_character_action.value := octets [index];

        = ORD (iic$vt_input_block_size) =
          IF number > 1 THEN
            i := octets [index] * 100(16);
            nam_os_defaults^.input_block_size.value := octets [index + 1] + i;
          ELSE
            nam_os_defaults^.input_block_size.value := octets [index];
          IFEND;

        = ORD (iic$vt_begin_line_character) =
          terminal_attributes^.begin_line_character :=CHR (octets [index]);

        = ORD (iic$vt_attention_character) =
          terminal_attributes^.attention_character := CHR (octets [index]);

        = ORD (iic$vt_hold_page_over) =
          terminal_attributes^.hold_page_over := (octets [index] <> 0);

        = ORD (iic$vt_carriage_return_sequence) =
          IF number <> 0 THEN
            FOR i := 0 TO (number - 1) DO
              terminal_attributes^.carriage_return_sequence.value (i + 1, 1) := CHR (octets [index + i]);
            FOREND;
          ELSE
            terminal_attributes^.carriage_return_sequence.value := '';
          IFEND;
          terminal_attributes^.carriage_return_sequence.size := number;

        = ORD (iic$vt_line_feed_sequence) =
          IF number <> 0 THEN
            FOR i := 0 TO (number - 1) DO
              terminal_attributes^.line_feed_sequence.value (i + 1, 1) := CHR (octets [index + i]);
            FOREND;
          ELSE
            terminal_attributes^.line_feed_sequence.value := '';
          IFEND;
          terminal_attributes^.line_feed_sequence.size := number;

        = ORD (iic$vt_form_feed_sequence) =
          IF number <> 0 THEN
            FOR i := 0 TO (number - 1) DO
              terminal_attributes^.form_feed_sequence.value (i + 1, 1) := CHR (octets [index + i]);
            FOREND;
          ELSE
            terminal_attributes^.form_feed_sequence.value := '';
          IFEND;
          terminal_attributes^.form_feed_sequence.size := number;

        = ORD (iic$vt_end_page_action) =
          IF octets [index] = 0 THEN
            terminal_attributes^.end_page_action := ifc$no_epa;
          ELSE
            terminal_attributes^.end_page_action := ifc$epa_ffs;
          IFEND;

        = ORD (iic$vt_form_feed_delay) =
          IF number > 1 THEN
            delay := octets [index] * 100(16);
            delay := delay + octets [index + 1];
            terminal_attributes^.form_feed_delay := delay;
          ELSE
            terminal_attributes^.form_feed_delay := octets [index];
          IFEND;

        = ORD (iic$vt_function_key_class) =
          IF number <> 0 THEN
            FOR i := 0 TO (number - 1) DO
              terminal_attributes^.function_key_class.value (i + 1, 1) := CHR (octets [index + i]);
            FOREND;
            terminal_attributes^.function_key_class.size := number;
          ELSE
            terminal_attributes^.function_key_class.value := '';
            terminal_attributes^.function_key_class.size := 1;
          IFEND;

        = ORD (iic$vt_terminal_model) =
          IF number <> 0 THEN
            FOR i := 0 TO (number - 1) DO
              terminal_attributes^.terminal_model.value (i + 1, 1) := CHR (octets [index + i]);
            FOREND;
            terminal_attributes^.terminal_model.size := number;
          ELSE
            terminal_attributes^.terminal_model.value := '';
            terminal_attributes^.terminal_model.size := 1;
          IFEND;

        = ORD (iic$vt_code_set) =
          CASE octets [index] OF
          = 0 =
            terminal_attributes^.code_set := ifc$ascii_code_set;
          = 1 =
            terminal_attributes^.code_set := ifc$bpapl_code_set;
          = 2 =
            terminal_attributes^.code_set := ifc$tpapl_code_set;
          ELSE
          CASEND;

        ELSE
        CASEND;
        index := index + number;

      UNTIL index > limit;

    { CDCNET does not return values for the following attributes: }

      field_values [iic$key_pause_break_character].field_value := 31(16);
      field_values [iic$key_term_break_character].field_value := 32(16);


    ELSE  { use the FN/FV pairs in the order that they were returned }

      field_values := term_char_definitions_message.term_char_definitions.
            term_char_string;

    IFEND;  { iiv$cdcnet_connection }


  /initialize_nam_os_defaults/
    BEGIN

    { Set input editing mode.

      field_value := field_values [iic$key_trans_input_mode].field_value;
      IF field_value = 0 THEN
        nam_os_defaults^.input_editing_mode.value := ifc$normal_edit;
      ELSE
        nam_os_defaults^.input_editing_mode.value := ifc$trans_edit;
      IFEND;

    { Set input output mode.

      field_value := field_values [iic$key_full_duplex].field_value;
      field_value2 := field_values [iic$key_solicited_mode].field_value;

      IF (field_value = 0) AND (field_value2 = 0) THEN
        nam_os_defaults^.input_output_mode.value := ifc$unsolicited_output;
      ELSEIF (field_value = 0) AND (field_value2 = 1) THEN
        nam_os_defaults^.input_output_mode.value := ifc$solicited;
      ELSEIF (field_value = 1) AND (field_value2 = 0) THEN
        nam_os_defaults^.input_output_mode.value := ifc$full_duplex;
      IFEND;

    { Set partial character forwarding.

      IF iiv$cdcnet_connection THEN
          nam_os_defaults^.partial_char_forwarding.value := FALSE;
      ELSE
        IF field_values [iic$key_input_device].field_value = 0 THEN
          nam_os_defaults^.partial_char_forwarding.value := FALSE;
        ELSEIF field_values [iic$key_input_device].field_value = 2 THEN
          nam_os_defaults^.partial_char_forwarding.value := TRUE;
        IFEND;
      IFEND;

    { Set store backspace character and store nuls dels.

      field_value := field_values [iic$key_full_ascii].field_value;
      field_value2 := field_values [iic$key_special_editing].field_value;
      nam_os_defaults^.store_backspace_character.value :=
            ((field_value = 0) AND (field_value2 = 1));
      nam_os_defaults^.store_nuls_dels.value :=
            (nam_os_defaults^.store_backspace_character.value AND (field_value = 1));

    { Set transparent character mode.

      field_value := field_values [iic$key_trans_delim_char_select].field_value;

      IF field_value = 0 THEN
        nam_os_defaults^.trans_character_mode.value := ifc$no_trans_char;
      ELSE
        field_value := field_values [iic$key_trans_input_type].field_value;
        IF field_value = 0 THEN
          nam_os_defaults^.trans_character_mode.value := ifc$trans_char_terminate;
        ELSEIF field_value = 1 THEN
          nam_os_defaults^.trans_character_mode.value := ifc$trans_char_fwd_terminate;
        IFEND;
      IFEND;

    { Set transparent length mode.

      xpt_count_value := field_values [iic$key_trans_delim_count_least].field_value;
      xpt_count_value := xpt_count_value + field_values [iic$key_trans_delim_count_most].
            field_value * 100(16);
      nam_os_defaults^.trans_message_length.value := xpt_count_value;
      IF xpt_count_value = 0 THEN
        nam_os_defaults^.trans_length_mode.value := ifc$no_trans_len;
      ELSE
        field_value := field_values [iic$key_trans_input_type].field_value;
        IF field_value = 0 THEN
          nam_os_defaults^.trans_length_mode.value := ifc$trans_len_terminate;
        ELSEIF field_value = 1 THEN
          nam_os_defaults^.trans_length_mode.value := ifc$trans_len_forward_exact;
        IFEND;
      IFEND;

    { Set transparent timeout mode.

      IF field_values [iic$key_trans_delim_timeout].field_value = 0 THEN
        nam_os_defaults^.trans_timeout_mode.value := ifc$no_trans_timeout;
      ELSEIF (field_values [iic$key_trans_mode_delim_lock].field_value = 0) OR
            iiv$cdcnet_connection THEN
        nam_os_defaults^.trans_timeout_mode.value := ifc$trans_timeout_terminate;
      ELSEIF field_values [iic$key_trans_input_type].field_value = 1 THEN
        nam_os_defaults^.trans_timeout_mode.value := ifc$trans_timeout_forward;
      IFEND;

    { Set transparent terminate character and forwarding character.

      field_value := field_values [iic$key_trans_delim_character].field_value;
      nam_os_defaults^.trans_forward_character.value.value (1) := CHR (field_value);
      IF nam_os_defaults^.trans_character_mode.value = ifc$trans_char_terminate THEN
        nam_os_defaults^.trans_terminate_character.value.value (1) := CHR (field_value);
      ELSE
        field_value := field_values [iic$key_trans_mode_delim_char].field_value;
        nam_os_defaults^.trans_terminate_character.value.value (1) := CHR (field_value);
      IFEND;
      nam_os_defaults^.trans_terminate_character.value.size := 1;
      nam_os_defaults^.trans_forward_character.value.size := 1;

     { Set attention character action and break key action.

      IF NOT iiv$cdcnet_connection THEN
        nam_os_defaults^.attention_character_action.value := 0;
        nam_os_defaults^.break_key_action.value := 0;
      IFEND;

    END /initialize_nam_os_defaults/;

  { Initialize term_char_values and active_term_char_values in connection descriptor. }

  /initialize_term_char_values/
    FOR i:=iic$key_user_break_1 to iic$key_trans_mode_delim_char DO
      cdp^.term_char_values [i]:= field_values [i].field_value;
      cdp^.active_term_char_values [i]:= field_values [i].field_value;
    FOREND /initialize_term_char_values/;

  /initialize_terminal_attributes/
    BEGIN

    { Set attention character.

      IF NOT iiv$cdcnet_connection THEN
        terminal_attributes^.attention_character := CHR (0(16));
      IFEND;

      IF (field_values [iic$key_trans_input_mode].field_value = 1) AND
            (terminal_attributes^.attention_character <> chr(00)) THEN

    { The following assignment can now be made since the attention character is determined.

        field_values [iic$key_trans_input_mode].field_value := 2; { xpt input mode w/user breaks enabled }
      IFEND;

    { Set backspace character.

      field_value := field_values [iic$key_backspace_character].field_value;
      terminal_attributes^.backspace_character := CHR (field_value);

    { Set begin line character.

      IF NOT iiv$cdcnet_connection THEN
        terminal_attributes^.begin_line_character := CHR (0(16));
      IFEND;

    { Set cancel line character.

      field_value := field_values [iic$key_cancel_line_character].field_value;
      terminal_attributes^.cancel_line_character := CHR (field_value);

    { Set carriage return delay.

      field_value := field_values [iic$key_cr_delay_count].field_value;
      terminal_attributes^.carriage_return_delay := field_value * 4;

    { Set character flow control.

      field_value := field_values [iic$key_output_flow_control].field_value;
      field_value2 := field_values [iic$key_input_flow_control].field_value;

      IF (field_value = 0) AND (field_value2 = 0) THEN
        terminal_attributes^.character_flow_control := FALSE;
      ELSE
        terminal_attributes^.character_flow_control := TRUE;
      IFEND;

    { Set echoplex.

      IF field_values [iic$key_echoplex].field_value = 0 THEN
        terminal_attributes^.echoplex := FALSE;
      ELSE
        terminal_attributes^.echoplex := TRUE;
      IFEND;

    { Set end line character.

      field_value := field_values [iic$key_end_line_character].field_value;
      terminal_attributes^.end_line_character := CHR (field_value);

    { Set end line positioning.

      field_value := field_values [iic$key_end_line_positioning].field_value;
      terminal_attributes^.end_line_positioning := iiv$upline_end_position_conv [field_value];

    { Set end output sequence.

      IF NOT iiv$cdcnet_connection THEN
        field_value := field_values [iic$key_pacer_prompting].field_value;
        terminal_attributes^.end_output_sequence.value (1)  := CHR (field_value);
        terminal_attributes^.end_output_sequence.size := 1;
      IFEND;

    { Set end partial character.

      field_value := field_values [iic$key_end_partial_character].field_value;
      terminal_attributes^.end_partial_character := CHR (field_value);

    { Set end partial positioning.

      field_value := field_values [iic$key_end_partial_positioning].field_value;
      terminal_attributes^.end_partial_positioning := iiv$upline_part_position_conv [field_value];

    { Set fold line.

      IF field_values [iic$key_output_device].field_value = 1 THEN
        terminal_attributes^.fold_line := FALSE;
      ELSEIF field_values [iic$key_output_device].field_value = 0 THEN
        terminal_attributes^.fold_line := TRUE;
      IFEND;

    { Set hold page.

      IF field_values [iic$key_hold_page].field_value = 0 THEN
        terminal_attributes^.hold_page := FALSE;
      ELSE
        terminal_attributes^.hold_page := TRUE;
      IFEND;

    { Set line feed delay.

      field_value := field_values [iic$key_lf_delay_count].field_value;
      terminal_attributes^.line_feed_delay := field_value * 4;

    { Set network command character.

      field_value := field_values [iic$key_network_cmd_character].field_value;
      terminal_attributes^.network_command_character := CHR (field_value);

    { Set page width.

      field_value := field_values [iic$key_page_width].field_value;
      IF field_value = 0 THEN
        terminal_attributes^.page_width := UPPERVALUE (ift$page_width);
      ELSE
        terminal_attributes^.page_width := field_value;
      IFEND;

    { Set page length.

      field_value := field_values [iic$key_page_length].field_value;
      IF field_value = 0 THEN
        terminal_attributes^.page_length := UPPERVALUE (ift$page_length);
      ELSE
        terminal_attributes^.page_length := field_value;
      IFEND;

    { Set parity.

      field_value := field_values [iic$key_parity].field_value;
      terminal_attributes^.parity := iiv$upline_parity_conv [field_value];
      IF (nam_os_defaults^.input_editing_mode.value =
            ifc$trans_edit) THEN

      { Select IGNORE PARITY if XPT mode is on and the 2**7 bit of either the TFC or TTC
      { is zero.  This tells the 2550 to ignore the parity bit when it is checking for the
      { TFC or TTC, which, in effect, allows, for example, a TFC of 0D(16) to successfully
      { compare with 8D(16).

        IF (ORD (nam_os_defaults^.trans_forward_character.value.
              value (1)) < 7F(16)) OR
              (ORD (nam_os_defaults^.trans_terminate_character.value.
              value (1)) < 7F(16)) THEN
          field_values [iic$key_parity].field_value := 4;
        IFEND;
      IFEND;

    { Set status action.

      IF field_values [iic$key_lockout_unsolicited_msg].field_value = 0 THEN
        terminal_attributes^.status_action := ifc$send_status;
      ELSE
        terminal_attributes^.status_action := ifc$hold_status;
      IFEND;

    { Set pause break character.

      field_value := field_values [iic$key_pause_break_character].field_value;
      terminal_attributes^.pause_break_character := CHR (field_value);

    { Set terminate break character.

      field_value := field_values [iic$key_term_break_character].field_value;
      terminal_attributes^.terminate_break_character := CHR (field_value);

    { Set terminal class.

      IF NOT iiv$cdcnet_connection THEN
        field_value := field_values [iic$key_terminal_class].field_value;
        terminal_attributes^.terminal_class := iiv$upline_term_class_conv [field_value];
      IFEND;

    END /initialize_terminal_attributes/;

    iip$clear_lock (cdp^.lock, local_status);

  PROCEND iip$set_default_attributes;

MODEND iim$set_default_attributes;
