SETTERM utility, part 3

In the previous articles, we started looking at SETTERM. We will finish up in this article.

First we'll consider the terminal definition file. sys$system:setterm.txt is a text file that contains options for different terminals, one per line. Each line starts with the name of a terminal model, an equal sign, and a series of switches that tell SETTERM how to configure the terminal. One of the names provided in the default file is "unknown". Additional terminals, and/or alterations to existing terminals, can be added to the file by the system administrator. I won't include the whole file here, but here's a couple of (truncated) lines:

la120=/noadvanced_video/noansi_crt/crfill=0/nodec_crt/nodec_crt5/form/hardcopy/page=66 vt100=/ansi_crt/crfill=0/dec_crt/nodec_crt2/noeight_bit/noform/scope/lffill=0/lowercase/page=24

This file both defines which terminal types are known, but also what characteristics to apply to a given terminal type. The following two functions in setterm use this file.

function Get_Device_Switches( S : string ) : string ;

var Buffer : PAnsiChar ;
    F : TCOM_UOS_File ;
    I : integer ;
    S1 : string ;       

begin
    Result := '' ;
    s := lowercase( S ) ;
    F := Open_Binary_File( 'sys$system:setterm.txt', FAB_V_GET or FAB_V_SHRALL ) ;
    while( not F.EOF ) do
    begin
        F.Readln( Buffer ) ;
        S1 := string( Buffer ) ;
        I := pos( '=', S1 ) ;
        if( S = lowercase( copy( S1, 1, I - 1 ) ) ) then
        begin
            Result := copy( S1, I + 1, length( S1 ) ) ;
            F.Free ;
            exit ;
        end ;
    end ;
    F.Free ;
end ;

This routine returns the switches associated with the passed terminal type. If no match is found in the setterm.txt file, a null string is returned.

function Get_Devices : string ;

var Buffer : PAnsiChar ;
    F : TCOM_UOS_File ;
    I : integer ;
    S1 : string ;

begin
    Result := '' ;
    F := Open_Binary_File( 'sys$system:setterm.txt', FAB_V_GET or FAB_V_SHRALL ) ;
    while( not F.EOF ) do
    begin
        F.Readln( Buffer ) ;
        S1 := string( Buffer ) ;
        I := pos( '=', S1 ) ;
        Result := Result + '"' + copy( S1, 1, I - 1 ) + '",' ;
    end ;
    F.Free ;
    setlength( Result, length( Result ) - 1 ) ; // Trim trailing comma
end ;

This routine iterates through the setterm.txt file, creating a comma-delimited list of known terminal types. Each type is surrounded with quotes so that the list is appropriate for a UUI list component.

Next, we will look at the QIO changes to support SETTERM. I should note that there are some differences from VMS here, in addition to the ones noted in the previous article. For instance, IO_SENSEMODE doesn't return information via p3-p6 in VMS, but does in UOS. Also, we use a single buffer size, whereas VMS is backwards compatible to earlier versions that had a smaller buffer size. UOS has a single buffer size, with a slightly modified layout. Here's the user documentation for the new QIO features (this expands upon the previous documentation):

IO_SENSEMODE function:
This function returns device-dependant information. The information is written to a buffer whose address is passed in parameter p1. This buffer has the following layout:

Mnuemonic Byte offset Byte length Description

Devclass 0 1 Device class to use. DC_TERM indicates a terminal.

DevType 1 1 unused.

PageWidth 2 2 Number of columns.

PageLength 4 2 Number of lines/rows.

Characteristics 6 8 Device flags.

p2 is the length of the buffer pointed to by p1. But since the buffer has a specific size in UOS, we will simply ignore it. If p3-p6 are not 0, they are interpreted as addresses of 8-byte buffers to receive additional terminal values. The following table indicates what each of the buffers receives, if the corresponding parameter is provided.

Parameter Description

p2 unused/ignored.

p3 Baud rate. The low 8 bits indicate the output baud rate. If bits 7-5 are not 0, they indicate the input baud rate (for split baud rates only).

p4 Number of fill characters. The lowest 8 bits are the CR fill and bits 7-15 are the LF fill.

p5 Parity. The low 4 bits contain the number of data bits. If the TT_M_DISPARERR flag is set then parity errors are ignored on this device. If the TT_M_PARITY flag is not set, no party bit is used. If the TT_M_ODD flag is set then the parity is odd, otherwise the parity is even (this bit has no meaning if no parity is being used).

p6 Type-ahead buffer size, in bytes.

IO_SETMODE and IO_SETCHAR functions:
IO_SETMODE is used to set current terminal characteristics, while IO_SETCHAR is used to set permanent terminal characteristics. For subfunctions, such as IOM_CTRLCAST, both functions operate the same. When no subfunction is used, terminal flags can be set. Parameter p1 points to a buffer that defines which characteristics to set. The buffer has the following layout:

Mnuemonic Byte offset Byte length Description

Devclass 0 1 Device class to use. DC_TERM indicates a terminal.

DevType 1 1 unused.

PageWidth 2 2 Number of columns.

PageLength 4 2 Number of lines/rows.

Characteristics 6 8 Device flags.

p3-p6 contain additional terminal attributes. The following table indicates what attributes are passed in p2-p6:

Parameter Description

p2 unused/ignored.

p3 Baud rate. The low 8 bits indicate the output baud rate. If bits 7-15 are not 0, they indicate the input baud rate (for split baud rates only).

p4 Number of fill characters. The lowest 8 bits are the CR fill and bits 7-15 are the LF fill.

p5 Parity. If the TT_M_ALTRPAR flag is included in this value, the parity is altered according to the TT_M_PARITY and TT_M_ODD flags (otherwise those flags are ignored). If the TT_M_DISPARERR flag is set in this parameter value then parity errors are ignored on this device. If the TT_M_ALTFRAME flag is included in this parameter value, the low 4 bits contain the number of data bits.

p6 If the TT_M_ALTYPEAHD flag is included in this value, the low 16 bits indicates the new type-ahead buffer size, in bytes.

The baud rates are defined as follows:

Mnuemonic Value

TT_C_BAUD_50 1
TT_C_BAUD_75 2
TT_C_BAUD_110 3
TT_C_BAUD_134 4
TT_C_BAUD_150 5
TT_C_BAUD_300 6
TT_C_BAUD_600 7
TT_C_BAUD_1200 8
TT_C_BAUD_1800 9
TT_C_BAUD_2000 10
TT_C_BAUD_2400 11
TT_C_BAUD_3600 12
TT_C_BAUD_4800 13
TT_C_BAUD_7200 14
TT_C_BAUD_9600 15
TT_C_BAUD_19200 16
TT_C_BAUD_38400 17
TT_C_BAUD_57600 18
TT_C_BAUD_76800 19
TT_C_BAUD_115200 20

Note that any of the attributes specified by p3-p6 are left unchanged if the corresponding parameter is 0.

Note that PHY_IO privilege is required to set permanent characteristics, and LOG_IO is required to set current settings unless speed settings are enabled (changing that setting also requires PHY_IO or LOG_IO). PHY_IO is also required to alter the type-ahead buffer size. However, virtual terminals have no permanent characteristics, thus setting permanent characteristics is the same as setting current characteristics, and requires no privileges.

            if( p3 <> 0 ) then // Return speed
            begin
                I64 := TFiP_Terminal_File( Resource._File ).Terminal.Speed ;
                I64 := Convert_to_Baud_Ordinal( I64 ) ;
                if(
                    ( TFiP_Terminal_File( Resource._File ).Terminal.Speed <> 0 )
                    and
                    ( TFiP_Terminal_File( Resource._File ).Terminal.Speed <> 
                        TFiP_Terminal_File( Resource._File ).Terminal.Input_Speed )
                  ) then
                begin
                    I64 := TFiP_Terminal_File( Resource._File ).Terminal.Input_Speed 
                        or ( TFiP_Terminal_File( Resource._File ).Terminal.Speed shl 8 ) ;
                end ;
                IOSB.r_io_64.w_status := Write_User( Kernel, PID, p3, sizeof( I64 ), I64 ) ;
                if( IOSB.r_io_64.w_status <> 0 ) then
                begin
                    exit ;
                end ;
            end ;
            if( p4 <> 0 ) then // Return fill counts
            begin
                I64 := TFiP_Terminal_File( Resource._File ).Terminal.CRFill or
                    ( TFiP_Terminal_File( Resource._File ).Terminal.LFFill shl 8 ) ;
                IOSB.r_io_64.w_status := Write_User( Kernel, PID, p4, sizeof( I64 ), I64 ) ;
                if( IOSB.r_io_64.w_status <> 0 ) then
                begin
                    exit ;
                end ;
            end ;
            if( p5 <> 0 ) then // Return parity information
            begin
                I64 := TFiP_Terminal_File( Resource._File ).Terminal.Bits ;
                case TFiP_Terminal_File( Resource._File ).Terminal.Parity of
                    1 : I64 := I64 or TT_M_PARITY or TT_M_ODD ;
                    2 : I64 := I64 or TT_M_PARITY ;
                end ;
                if( TFiP_Terminal_File( Resource._File ).Terminal.Ignore_Errors ) then
                begin
                    I64 := I64 or TT_M_DISPARERR ;
                end ;
                IOSB.r_io_64.w_status := Write_User( Kernel, PID, p5, sizeof( I64 ), I64 ) ;
                if( IOSB.r_io_64.w_status <> 0 ) then
                begin
                    exit ;
                end ;
            end ;
            if( p6 <> 0 ) then // Return type-ahead buffer size
            begin
                I64 := TFiP_Terminal_File( Resource._File ).Terminal._Input_Filter.Buffer_Size ;
                IOSB.r_io_64.w_status := Write_User( Kernel, PID, p6, sizeof( I64 ), I64 ) ;
                if( IOSB.r_io_64.w_status <> 0 ) then
                begin
                    exit ;
                end ;
            end ;

This code is added to the IO_SENSEMODE function processing the FIP.QIO method. It checks each of the parameters p3 through p6 for non-zero values. If any of the values are non-zero, the addresses are used as destinations to write the information for the corresponding data, as described in the documentation.

    if( ( Func and IO_Function_Mask ) = IO_SETCHAR ) then
    begin
        case Mode of
            0 : // Set permanent characteristics
                begin
                    Get_User_Data( Kernel, Kernel.PID, p1, sizeof( Buffer ), Buffer, IOSB.r_io_64.w_status ) ;
                    if( IOSB.r_io_64.w_status = UE_Error ) then
                    begin
                        exit ;
                    end ;
                    If( Buffer.DevClass <> DC_TERM ) then // Only terminals are supported at present
                    begin
                        IOSB.r_io_64.w_status := SS_ACCVIO ;
                        Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                        exit ;
                    end ;
                    if( TFiP_Terminal_File( Resource._File ).Terminal = nil ) then // Not a terminal
                    begin
                        IOSB.r_io_64.w_status :=  UOSErr_Invalid_Operation ; // Probably ACCVIO in VMS
                        Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                        exit ;
                    end ;
                    if( ( USC.Get_Process_Info( PID, JPI_CURPRIV ) and PHY_IO ) = 0 ) then
                    begin
                        IOSB.r_io_64.w_status := UOSErr_Protection_Violation ;
                        Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                        exit ;
                    end ;

We've updated and expanded the IO_SETCHAR function of QIO to handle the other terminal characteristics. First we get the buffer and exit with an error, as before. Next we check that the device class in the buffer is DC_TERM and exit with an error if not. In the future, we will support other device types for IO_SETCHAR, but for now, only terminals are handled. Next we make sure that the device actually is a terminal. If not, we exit with an error. Finally, we check that the user has the PHY_IO privilege - which is required for the IO_SETCHAR function.

                    TFiP_Terminal_File( Resource._File ).Terminal.Permanent_Terminal_Flags :=
                        Buffer.Characteristics ;
                    if( Buffer.PageWidth <> 0 ) then
                    begin
                        TFiP_Terminal_File( Resource._File ).Terminal.Permanent_Max_Char_Rows :=
                            Buffer.PageWidth ;
                    end ;
                    if( Buffer.PageLength <> 0 ) then
                    begin
                        TFiP_Terminal_File( Resource._File ).Terminal.Permanent_Max_Char_Columns :=
                            Buffer.PageLength ;
                    end ;
                    if( p3 <> 0 ) then // Set speed
                    begin
                        Get_User_Data( Kernel, PID, P3, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        I64 := TFiP_Terminal_File( Resource._File ).Terminal.Speed ;
                        I64 := Convert_to_Baud_Ordinal( I64 ) ;
                        if(
                            ( TFiP_Terminal_File( Resource._File ).Terminal.Speed <> 0 )
                            and
                            ( TFiP_Terminal_File( Resource._File ).Terminal.Speed <> 
                                TFiP_Terminal_File( Resource._File ).Terminal.Input_Speed )
                          ) then
                        begin
                            I64 := TFiP_Terminal_File( Resource._File ).Terminal.Input_Speed 
                                or ( TFiP_Terminal_File( Resource._File ).Terminal.Speed shl 8 ) ;
                        end ;
                    end ;
                    if( p4 <> 0 ) then // Set fill counts
                    begin
                        Get_User_Data( Kernel, PID, P4, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        TFiP_Terminal_File( Resource._File ).Terminal.CRFill := I64 and 255 ;
                        TFiP_Terminal_File( Resource._File ).Terminal.LFFill := I64 shl 8 ;
                    end ;
                    if( p5 <> 0 ) then // Set parity information
                    begin
                        Get_User_Data( Kernel, PID, P5, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        if( ( I64 and TT_M_PARITY ) <> 0 ) then
                        begin
                            TFiP_Terminal_File( Resource._File ).Terminal.Bits := I64 and 15 ;
                            if( ( I64 and TT_M_ODD ) <> 0 ) then
                            begin
                                TFiP_Terminal_File( Resource._File ).Terminal.Parity := Parity_Odd ;
                            end else
                            begin
                                TFiP_Terminal_File( Resource._File ).Terminal.Parity := Parity_Even ;
                            end ;
                        end else
                        begin
                            TFiP_Terminal_File( Resource._File ).Terminal.Parity := Parity_None ;
                        end ;
                        if( ( I64 and TT_M_DISPARERR ) <> 0 ) then
                        begin
                            TFiP_Terminal_File( Resource._File ).Terminal.Ignore_Errors := True ;
                        end ;
                    end ;
                    if( p6 <> 0 ) then // Set type-ahead buffer size
                    begin
                        if( ( USC.Get_Process_Info( PID, JPI_CURPRIV ) and PHY_IO ) = 0 ) then
                        begin
                            // PHY_IO required to set the buffer size...
                            IOSB.r_io_64.w_status := UOSErr_Protection_Violation ;
                            Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                            exit ;
                        end ;
                        Get_User_Data( Kernel, PID, P6, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        if( I64 < 256 ) then
                        begin
                            I64 := 256 ; // Minimum buffer size
                        end ;
                        TFiP_Terminal_File( Resource._File ).Terminal._Input_Filter.Buffer_Size := I64 ;
                    end ;
                end ;
        end ; // case Mode

Next, we update the terminal characteristics. For parameters p3-p6, we essentially do the inverse of the IO_SENSEMODE function, reading the new value from the user memory, unpacking them, and then setting the terminal attributes.

            0 : // Set current characteristics
                begin
                    Get_User_Data( Kernel, PID, P1, sizeof( Buffer ), Buffer, IOSB.r_io_64.w_status ) ;
                    if( IOSB.r_io_64.w_status = UE_ERROR ) then
                    begin
                        exit ;
                    end ;
                    If( Buffer.DevClass <> DC_TERM ) then // Only terminals are supported at present
                    begin
                        IOSB.r_io_64.w_status := SS_ACCVIO ;
                        Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                        exit ;
                    end ;
                    if( TFiP_Terminal_File( Resource._File ).Terminal = nil ) then // Not a terminal
                    begin
                        IOSB.r_io_64.w_status :=  UOSErr_Invalid_Operation ; // Probably ACCVIO in VMS
                        Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                        exit ;
                    end ;
                    if( USC.Get_Process_Info( PID, JPI_CURPRIV ) and ( PHY_IO or LOG_IO ) = 0 ) then
                    begin
                        if( ( TFiP_Terminal_File( Resource._File ).Terminal.Terminal_Flags and TT2_M_SETSPEED ) = 0 ) then
                        begin
                            // If terminal doesn't have SETSPEED flag set, the user needs either PHY_IO or LOG_IO
                            IOSB.r_io_64.w_status := UOSErr_Protection_Violation ;
                            Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                            exit ;
                        end ;
                    end ;
                    if(
                        ( Buffer.Characteristics and TT2_M_SETSPEED ) <>
                        ( TFiP_Terminal_File( Resource._File ).Terminal.Permanent_Terminal_Flags and TT2_M_SETSPEED )
                      ) then // Changing setspeed flag
                    begin
                        if(
                            ( USC.Get_Process_Info( PID, JPI_CURPRIV )
                            and
                            ( PHY_IO or LOG_IO ) ) = 0 ) then
                        begin
                            IOSB.r_io_64.w_status := UOSErr_Protection_Violation ;
                            Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                            exit ;
                        end ;
                    end ;

This code is added to the IO_SETMODE function in QIO. It is similar to the code for IO_SETCHAR above except for the privilege check. In IO_SETCHAR, we require PHY_IO. Here, we only require privileges if the terminal doesn't have the the SETSPEED flag set. Since we are setting the current settings, rather than the permanent settings, either the PHY_IO or LOG_IO privilege will suffice. The user must also have either PHY_IO or LOG_IO to change the setspeed flag.

                    TFiP_Terminal_File( Resource._File ).Terminal.Terminal_Flags :=
                        Buffer.Characteristics ;
                    if( Buffer.PageWidth <> 0 ) then
                    begin
                        TFiP_Terminal_File( Resource._File ).Terminal.Max_Char_Rows :=
                            Buffer.PageWidth ;
                    end ;
                    if( Buffer.PageLength <> 0 ) then
                    begin
                        TFiP_Terminal_File( Resource._File ).Terminal.Max_Char_Columns :=
                            Buffer.PageLength ;
                    end ;
                    if( p3 <> 0 ) then // Set speed
                    begin
                        Get_User_Data( Kernel, PID, P3, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        TFiP_Terminal_File( Resource._File ).Terminal.Input_Speed :=
                            Convert_to_Baud_Rate( I64 and 255 ) ;
                        TFiP_Terminal_File( Resource._File ).Terminal.Speed :=
                            Convert_to_Baud_Rate( I64 shr 8 ) ;
                    end ;
                    if( p4 <> 0 ) then // Set fill counts
                    begin
                        Get_User_Data( Kernel, PID, P4, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        TFiP_Terminal_File( Resource._File ).Terminal.CRFill := I64 and 255 ;
                        TFiP_Terminal_File( Resource._File ).Terminal.LFFill := I64 shl 8 ;
                    end ;
                    if( p5 <> 0 ) then // Set parity information
                    begin
                        Get_User_Data( Kernel, PID, P5, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        if( ( I64 and TT_M_PARITY ) <> 0 ) then
                        begin
                            TFiP_Terminal_File( Resource._File ).Terminal.Bits := I64 and 15 ;
                            if( ( I64 and TT_M_ODD ) <> 0 ) then
                            begin
                                TFiP_Terminal_File( Resource._File ).Terminal.Parity := Parity_Odd ;
                            end else
                            begin
                                TFiP_Terminal_File( Resource._File ).Terminal.Parity := Parity_Even ;
                            end ;
                        end else
                        begin
                            TFiP_Terminal_File( Resource._File ).Terminal.Parity := Parity_None ;
                        end ;
                        if( ( I64 and TT_M_DISPARERR ) <> 0 ) then
                        begin
                            TFiP_Terminal_File( Resource._File ).Terminal.Ignore_Errors := True ;
                        end ;
                    end ;
                    if( p6 <> 0 ) then // Set type-ahead buffer size
                    begin
                        if( ( USC.Get_Process_Info( PID, JPI_CURPRIV ) and PHY_IO ) = 0 ) then
                        begin
                            // PHY_IO required to set the buffer size...
                            IOSB.r_io_64.w_status := UOSErr_Protection_Violation ;
                            Set_Last_Error( Create_Error( IOSB.r_io_64.w_status ) ) ;
                            exit ;
                        end ;
                        Get_User_Data( Kernel, PID, P6, sizeof( I64 ), I64, IOSB.r_io_64.w_status ) ;
                        if( IOSB.r_io_64.w_status = UE_ERROR ) then
                        begin
                            exit ;
                        end ;
                        if( I64 < 256 ) then
                        begin
                            I64 := 256 ; // Minimum buffer size
                        end ;
                        TFiP_Terminal_File( Resource._File ).Terminal._Input_Filter.Buffer_Size := I64 ;
                    end ;
                end ;

This code is almost exactly the same as the IO_SETCHAR code, except that it sets the current settings instead of the permanent settings.

function Convert_to_Baud_Rate( I : integer ) : integer ;

begin
    case I of
        TT_C_BAUD_50 : Result := 50 ;
        TT_C_BAUD_75 : Result := 75 ;
        TT_C_BAUD_110 : Result := 110 ;
        TT_C_BAUD_134 : Result := 134 ;
        TT_C_BAUD_150 : Result := 150 ;
        TT_C_BAUD_300 : Result := 300 ;
        TT_C_BAUD_600 : Result := 600 ;
        TT_C_BAUD_1200 : Result := 1200 ;
        TT_C_BAUD_1800 : Result := 1800 ;
        TT_C_BAUD_2000 : Result := 2000 ;
        TT_C_BAUD_2400 : Result := 2400 ;
        TT_C_BAUD_3600 : Result := 3600 ;
        TT_C_BAUD_4800 : Result := 4800 ;
        TT_C_BAUD_7200 : Result := 7200 ;
        TT_C_BAUD_9600 : Result := 9600 ;
        TT_C_BAUD_19200 : Result := 19200 ;
        TT_C_BAUD_38400 : Result := 38400 ;
        TT_C_BAUD_57600 : Result := 57600 ;
        TT_C_BAUD_76800 : Result := 76800 ;
        TT_C_BAUD_115200 : Result := 115200 ;
        else Result := 0 ;
    end ;
end ;


function Convert_to_Baud_Ordinal( I : integer ) : integer ;

begin
    case I of
        50 : Result := TT_C_BAUD_50 ;
        75 : Result := TT_C_BAUD_75 ;
        110 : Result := TT_C_BAUD_110 ;
        134 : Result := TT_C_BAUD_134 ;
        150 : Result := TT_C_BAUD_150 ;
        300 : Result := TT_C_BAUD_300 ;
        600 : Result := TT_C_BAUD_600 ;
        1200 : Result := TT_C_BAUD_1200;
        1800 : Result := TT_C_BAUD_1800;
        2000 : Result := TT_C_BAUD_2000 ;
        2400 : Result := TT_C_BAUD_2400 ;
        3600 : Result := TT_C_BAUD_3600 ;
        4800 : Result := TT_C_BAUD_4800 ;
        7200 : Result := TT_C_BAUD_7200 ;
        9600 : Result := TT_C_BAUD_9600 ;
        19200 : Result := TT_C_BAUD_19200 ;
        38400 : Result := TT_C_BAUD_38400 ;
        57600 : Result := TT_C_BAUD_57600 ;
        76800 : Result := TT_C_BAUD_76800 ;
        115200 : Result := TT_C_BAUD_115200 ;
        else Result := 0 ;
    end ;
end ;

These two functions convert between the baud rate constants used by VMS and the actual baud rate value used by UOS.

This concludes the changes to support SETTERM. However, with modern computer equipment, it is unlikely that most UOS users will ever need to deal with any terminal characteristics other than turning echo on and off. I'll end with a brief discussion of character echoing.

You might wonder why we have two different terminal characteristics that deal with echoing (LOCALECHO and HALFDUP). Either one will turn off the echo. Why two rather than a single characteristic? They should be viewed this way: HALFDUP indicates whether the terminal echoes its own characters and we don't want to modify this value to turn echo on or off. ECHO/LOCALECHO, on the other hand, indicates whether or not we want to echo characters to the terminal (regardless of the duplex), usually for security purposes. We want to be able to change the echo without altering the HALFDUP setting. If a terminal is half-duplex, turning ECHO back on will still not echo to the terminal. But, if we modified the HALFDUP setting to turn the echo back on and the terminal hardware is in local echo mode, we will essentially cause a doubling of each character (one from the terminal's local echo and one from the UOS echo). To put it another way, HALFDUP tells UOS how the hardware is configured, whereas ECHO indicates what UOS should do, regardless of the duplex setting. Thus, UCL scripts can safely turn the echo on and off via SETTERM/LOCALECHO without causing actual UOS echoing when there shouldn't be any. Admittedly, the opposite of ECHO being LOCALECHO somewhat muddies the terminology (it really should be NOECHO), but such is the cost of using the VMS specification.

In the next article, we will begin our look at the AUTHORIZE utility.