"                                                                              "
"   TERMINAL DEFINITION FILE FOR -------------- TERMINAL                       "
"                                                                              "
"        The Define_Terminal command (DEFT) allows user definition of most     "
"   character mode asynchronous type terminals for use with all NOS/VE         "
"   full screen products.  A detailed description of Define_Terminal can       "
"   be found in the Terminal Definition for NOS/VE Manual.                     "
"                                                                              "
"        There should be a collection of system defined terminal               "
"   definition files on file $SYSTEM.CYBIL.OSF$PROGRAM_INTERFACE that may      "
"   assist you (and perhaps already define your terminal or one that is        "
"   very similar to it).  The deck names and the terminals that they           "
"   define should include:                                                     "
"                                                                              "
"        CSM$SAMPLE          This template for definitions                     "
"        CSM$CDC_721         CDC 721 (Viking X)                                "
"        CSM$CDC_722         CDC 722                                           "
"        CSM$CDC_722_30      CDC 722_30                                        "
"        CSM$PC_CONNECT_10   IBM PC with version 1.0 CONNECT                   "
"        CSM$PC_CONNECT_11   IBM PC with version 1.1 CONNECT                   "
"        CSM$PC_CONNECT_12   IBM PC with version 1.2 CONNECT                   "
"        CSM$PC_CONNECT_13   IBM PC with version 1.3 CONNECT                   "
"        CSM$MAC_CONNECT_10  APPLE MACINTOSH with version 1.0 CONNECT          "
"        CSM$MAC_CONNECT_11  APPLE MACINTOSH with version 1.1 CONNECT          "
"        CSM$DEC_VT100       DEC VT100                                         "
"        CSM$DEC_VT100_GOLD  DEC VT100 with extra function key combinations    "
"        CSM$DEC_VT220       DEC VT220                                         "
"        CSM$ZEN_Z19         ZENITH Z19/HEATHKIT H19                           "
"        CSM$ZEN_Z29         ZENITH Z29/HEATHKIT H29                           "
"        CSM$IBM_3270        IBM 3270                                          "
"                                                                              "
"        Other definitions may also be present.                                "
"                                                                              "
"        Use the following commands to extract one of these decks into a       "
"   file (named MYFILE) you can manipulate:                                    "
"                                                                              "
"        SCU                                                                   "
"        USE_LIBRARY BASE=$SYSTEM.CYBIL.OSF$PROGRAM_INTERFACE RESULT=$NULL     "
"        EXTRACT_DECK DECK=CSM$name   SOURCE=MYFILE                            "
"        END WRITE_LIBRARY=NO                                                  "
"                                                                              "
"        Where "name" is the definition that most closely matches the terminal "
"   that you wish to define.  If you cannot identify one that is a close match "
"   then you can use this deck, CSM$SAMPLE, which contains all possible        "
"   statement with blanks to fill in.                                          "
"                                                                              "
"        The extracted file, MYFILE is the input file that you will fill with  "
"   the specific terminal dependent data that you should find in the           "
"   hardware reference manual for your terminal.  When the sequences,          "
"   capabilities and attributes of your terminal have been filled in you       "
"   will then compile your terminal definition by using the system command     "
"   Define_Terminal.  This will produce a file named TERMINAL_DEFINITIONS      "
"   which contains an encapsulated copy of the information needed by           "
"   NOS/VE screen formatting products to utilize your terminal.                "
"                                                                              "
"        A number of capabilities are required for your terminal to            "
"   function in screen mode.  These are a clear_page_stay or a                 "
"   clear_page_home, a cursor_home, and the ability to directly position       "
"   the cursor on the screen.  At least a subset (F1 - F16 or F1 - F8 plus     "
"   F1_S - F8_S) of the application keys should be defined. An                 "
"   erase_end_of_line capability is not required but will provide              "
"   considerably better performance for all full screen products.              "
"                                                                              "
"        Any line surrounded by quotation marks (such as this text) is a       "
"   comment line and will be ignored when compiling your terminal capsule.     "
"   This is a way in which you can add your own comments to this file as       "
"   you proceed to fill in the requested information.  Those lines that        "
"   are not surrounded by quotation marks in this file are the input           "
"   directives to Define_Terminal for which you will fill in the correct       "
"   values for your terminal.                                                  "
"                                                                              "
"        Define_Terminal allows you to define variables for commonly used      "
"   character strings and recognizes ASCII mnemonics (such as rs, ack).        "
"   Both your variables and the mnemonics can be used anywhere in this         "
"   file.                                                                      "
"                                                                              "
"        Here are some examples to assist you in your definitions:             "
"                                                                              "
"   VARIABLES                                                                  "
"                                                                              "
"   set_line_mode   = ()          Empty sequence.                              "
"   set_line_mode   = (rs ack)    ASCII mnemonics.                             "
"   set_line_mode   = (14(8))     (8) indicates an octal value.                "
"   set_line_mode   = (14(16))    (16) indicates a hexadecimal value.          "
"   set_line_mode   = (14)        Any nonsubscripted number is decimal.        "
"   blank_character = (' ')       Blank character (see line drawing).          "
"   start_underline = (rs '=')    ASCII Mnemonic and character.                "
"   stop_underline  = (rs '''')   Use of apostrophe.                           "
"                                                                              "
"        There are several basic types of statements that you will             "
"   encounter in this file:                                                    "
"                                                                              "
"   o    VALUE STATEMENTS                                                      "
"                                                                              "
"        terminal_model           value = 'myown'                              "
"        has_protect              value = TRUE                                 "
"        function_key_leaves_mark value = 0                                    "
"                                                                              "
"        Where VALUE is TRUE, FALSE, an alphabetic string or a number.         "
"                                                                              "
"   o    TYPE STATEMENTS                                                       "
"                                                                              "
"        cursor_pos_encoding      type  = ansi_cursor                          "
"        char_past_last_position  type  = wrap_adjacent_next                   "
"                                                                              "
"        Where TYPE is one of a predefined list of choices that will           "
"        be listed preceding the statement.                                    "
"                                                                              "
"   o    IN STATEMENTS                                                         "
"                                                                              "
"        f1                       in    = (rs 71(16))                          "
"        help                     in    = (rs 5C(16))                          "
"                                                                              "
"        Where IN is the sequence that comes upline from the terminal          "
"        when a specific function is performed or key is pressed.              "
"                                                                              "
"   o    OUT STATEMENTS                                                        "
"                                                                              "
"        cursor_pos_begin         out   = (stx)                                "
"        bell_nak                 out   = (bel)                                "
"                                                                              "
"        Where OUT is the sequence sent down line to the terminal to           "
"        perform a certain function.                                           "
"                                                                              "
"   o    INOUT STATEMENTS                                                      "
"                                                                              "
"        erase_page_home          inout = (ff)                                 "
"        tab_forward              inout = (ht)                                 "
"                                                                              "
"        Where INOUT is the identical sequence sent up and down line           "
"        for a certain function.                                               "
"                                                                              "
"        It should be noted that you may break any INOUT statement like        "
"                                                                              "
"        tab_forward              inout = (ht)                                 "
"                                                                              "
"        into a matched pair of statements like                                "
"                                                                              "
"        tab_forward              in    = (ht)                                 "
"        tab_forward              out   = (ht)                                 "
"                                                                              "
"        You will need to do this if your terminal sends a different           "
"        sequence downline to the terminal than is sent upline when a          "
"        particular function is performed.  If in our example                  "
"        your terminal recognized ht (from the host) as a signal               "
"        to perform a tab forward but sent vt (to the host) to indicate        "
"        that the tab forward key had been pressed then the single             "
"        tab_forward inout = () statement would be split into:                 "
"                                                                              "
"        tab_forward              in    = (vt)  [in from the terminal]         "
"        tab_forward              out   = (ht)  [out to the terminal]          "
"                                                                              "
"        Any statement that is IN or OUT only should be left as is.            "
"                                                                              "
"   TD COMPILER STATEMENT DESCRIPTIONS AND COMMENTS                            "
"                                                                              "
"        The file from this point on is arranged by functional groups and      "
"        contains comments for each directive that should assist you in        "
"        filling in the correct sequences for your terminal.                   "
"                                                                              "
"   TERMINAL MODEL AND COMMUNICATION TYPE                                      "
"                                                                              "
"        The terminal_model or model_name is a 1 to 25 character alphanumeric  "
"        name for your terminal.  Lower case letters are translated to upper   "
"        case.  The value specified here is the same name used on the SETTA or "
"        ACTS command.                                                         "
"                                                                              "
    terminal_model      value = 'XXXXXX'
"                                                                              "
"        Communication type is always specified as asynch, but is actually     "
"        disregarded as the network provides all necessary processing for      "
"        synchronous or asynchronous modes.                                    "
"                                                                              "
    communications      type  = asynch
"                                                                              "
"   INITIALIZE TERMINAL COMMAND                                                "
"                                                                              "
"        With this directive any SCL command may be executed during screen     "
"        mode activation.                                                      "
"                                                                              "
    initialize_terminal setta_command = 'any SCL command'
"                                                                              "
"   END OF INFORMATION SPECIFICATION                                           "
"                                                                              "
"        This directive is allowed for NOS compatibility but has no effect     "
"        with NOS/VE.                                                          "
"                                                                              "
    end_of_information  in    = (0)
"                                                                              "
"   CURSOR POSITIONING INFORMATION                                             "
"                                                                              "
"        The way in which your terminal encodes cursor positioning will        "
"        determine your choice for cursor_pos_encoding and                     "
"        cursor_pos_column_first.  The general format for cursor               "
"        positioning is:                                                       "
"                                                                              "
"        Let X    --------------> represent the column coordinate.             "
"        Let Y    --------------> represent the row coordinate.                "
"        Let a    --------------> represent cursor_pos_begin.                  "
"        Let b    --------------> represent cursor_pos_second.                 "
"        Let c    --------------> represent cursor_pos_third.                  "
"        And Bias --------------> is the integer value added to the            "
"                                 row or column for cursor positioning.        "
"                                 You should be able to find the value         "
"                                 for bias in the harware reference            "
"                                 manual for your terminal (often 20(16)).     "
"                                                                              "
"        Then cursor_pos_encoding will be one of four types:                   "
"                                                                              "
"             ansi_cursor   ----> Those terminals which are ansi standard      "
"                                 and use decimalized cursor coordinates.      "
"                                 Format is:                                   "
"                                      a (X + bias) b (Y + bias) c             "
"                                      a (Y + bias) b (X + bias) c             "
"                                 the order of X and Y for your terminal       "
"                                 determines the value for                     "
"                                 cursor_pos_column_first.                     "
"                                                                              "
"             cdc721_cursor ----> The Control Data 721 (Viking X) terminal.    "
"                                 Format is:                                   "
"                                      a   (X + bias)     (Y + bias)           "
"                                          (if X is less than 81)              "
"                                      a b (X + bias -80) (Y + bias)           "
"                                          (if X greater than 80)              "
"                                                                              "
"             binary_cursor ----> Those terminals which use direct co-         "
"                                 ordinate positioning.                        "
"                                 Format is:                                   "
"                                      a (X + bias) b (Y + bias) c             "
"                                      a (Y + bias) b (X + bias) c             "
"                                 the order of X and Y for your terminal       "
"                                 determines the value for                     "
"                                 cursor_pos_column_first.                     "
"                                                                              "
"             ibm3270_cursor ---> A specialized protocol for the 3270.         "
"                                                                              "
    cursor_pos_encoding      bias  = (0)    type = XXXX_cursor
"                                                                              "
"        Cursor_pos_column_first has a value of TRUE if your terminal          "
"        sends the X (or column) coordinate followed by the Y (or row)         "
"        coordinate and has a value of FALSE if the reverse is true.           "
"                                                                              "
    cursor_pos_column_first  value = TRUE
"                                                                              "
"        Cursor_pos_column_length and row_length apply only to ANSI type       "
"        cursor position (these are zero for both other types) and are         "
"        non-zero only if your terminal sends a fixed number of                "
"        decimalized bytes for the column and row coordinates (as opposed      "
"        to a variable number which is the usual case).                        "
"                                                                              "
    cursor_pos_column_length value = (0)
    cursor_pos_row_length    value = (0)
"                                                                              "
"        Cursor_pos_begin, second and third are the sequences sent before      "
"        the first coordinate, in between coordinates and after the last       "
"        coordinate when positioning the cursor (a b and c in the formats      "
"        shown above).  At least a cursor_pos_begin should be supplied for     "
"        your terminal though second and third are often an empty sequence     "
"        and can be left alone.                                                "
"                                                                              "
    cursor_pos_begin         out   = (XXXX)
    cursor_pos_second        out   = ()
    cursor_pos_third         out   = ()
"                                                                              "
"   CURSOR MOVEMENT INFORMATION                                                "
"                                                                              "
"        Cursor_home, up, down, left and right are the sequences sent both     "
"        downline to the terminal to move the cursor to the home position      "
"        or a single column or row up, down, left, or right and upline         "
"        from the terminal when a cursor key is pressed.  Since this is        "
"        both an upline and downline sequence the INOUT keyword is used.       "
"                                                                              "
"        The Label parameter should be added to the cursor_home statement      "
"        if you are certain that the terminal really has a home key, or left   "
"        out if you are making a generic definition for several terminals of   "
"        which some might not actually have the key.  VT100 is an example of   "
"        a generic terminal for which the Home key may or may not be available."
"                                                                              "
    cursor_home              inout = ()  label='something if existence certain'"
    cursor_up                inout = ()
    cursor_down              inout = ()
    cursor_left              inout = ()
    cursor_right             inout = ()
"                                                                              "
"   CURSOR BEHAVIOR (for cursor movement keys)                                 "
"                                                                              "
"        Move_past_right, left, top and bottom describe what happens when      "
"        the cursor on your terminal is urged to move past the right,          "
"        left, top and bottom of the screen by a cursor movement key (not      "
"        by cursor movement caused by character input or a separate            "
"        backspace key your terminal may have in addition to a cursor left     "
"        key, these behaviors may be different from those for cursor           "
"        positioning keys and will be defined in the next section).  The       "
"        possible types are:                                                   "
"                                                                              "
"             wrap_adjacent_next ----> The cursor wraps to the other end       "
"                                      of the screen on the adjacent row       "
"                                      (next row cursor_right or previous      "
"                                      row for cursor_left)                    "
"             wrap_same_next     ----> The cursor wraps to the other           "
"                                      end of the screen still in the          "
"                                      same row or column.                     "
"             scroll_next        ----> The terminal scrolls.                   "
"             stop_next          ----> The cursor stops                        "
"             home_next          ----> The cursor homes.                       "
"                                                                              "
    move_past_right          type  = XXXX
    move_past_left           type  = XXXX
    move_past_top            type  = XXXX
    move_past_bottom         type  = XXXX
"                                                                              "
"   CURSOR BEHAVIOR (for character keys)                                       "
"                                                                              "
"        Char_past_right, left and last_postion describe what happens when     "
"        the cursor on your terminal is urged to move past the right, left     "
"        and end of the screen by character input or a separate backspace      "
"        key your terminal has in addition to (or in place of) a cursor        "
"        left key.  The possible behaviors are the same as those for           "
"        cursor positioning keys.                                              "
"                                                                              "
"             wrap_adjacent_next ----> The cursor wraps to the other end       "
"                                      of the screen on the adjacent row       "
"                                      (next row cursor_right or previous      "
"                                      row for cursor_left)                    "
"             wrap_same_next     ----> The cursor wraps to the other           "
"                                      end of the screen still in the          "
"                                      same row or column.                     "
"             scroll_next        ----> The terminal scrolls.                   "
"             stop_next          ----> The cursor stops                        "
"             home_next          ----> The cursor homes.                       "
"                                                                              "
    char_past_right          type  = XXXX
    char_past_left           type  = XXXX
    char_past_last_position  type  = XXXX
"                                                                              "
"   TERMINAL ATTRIBUTES                                                        "
"                                                                              "
"        These statements describe various attributes and capabilites of       "
"   your terminal that should be either TRUE or FALSE.                         "
"                                                                              "
"        Automatic_tabbing is TRUE if your terminal supports tabbing from      "
"        one completed filled unprotected input field to the next without      "
"        requiring that a tab key is pressed.                                  "
"                                                                              "
    automatic_tabbing        value = FALSE
"                                                                              "
"        Clears_when_change_size is TRUE if your terminal has more than        "
"        one screen size and changing screen sizes causes the screen to be     "
"        cleared.                                                              "
"                                                                              "
    clears_when_change_size  value = FALSE
"                                                                              "
"        Function_key_leaves_mark is non-zero if pressing a function key       "
"        on your terminal leaves a visible mark or character on the screen     "
"        or if function keys for your terminal will be supported by an         "
"        escape or control sequence that will require a character to           "
"        complete.  The full screen editor will then know to rewrite the       "
"        line on the screen that has been overwritten by the mark or           "
"        character(s).                                                         "
"                                                                              "
"        Note that the NOS/VE Define_Terminal command is incompatible with     "
"        the NOS TDU facility for this directive, as NOS uses TRUE/FALSE       "
"        boolean values for this directive rather than an integer count of     "
"        characters.                                                           "
"                                                                              "
    function_key_leaves_mark value = 0
"                                                                              "
"        Has_hidden is TRUE if your terminal supports a hidden attribute       "
"        that allows a field to be defined as input only such that typed       "
"        characters are not displayed on the screen.                           "
"                                                                              "
    has_hidden               value = FALSE
"                                                                              "
"        Has_protect is TRUE if the terminal hardware supports a protected     "
"        field attribute so that users can only enter data within              "
"        specified areas on the screen.                                        "
"                                                                              "
    has_protect              value = FALSE
"                                                                              "
"        Home_at_top is TRUE if the cursor goes to the top of the screen       "
"        when the home key is pressed or FALSE if it goes to the bottom.       "
"                                                                              "
    home_at_top              value = FALSE
"                                                                              "
"        Multiple_sizes is true if your terminal has more than one screen      "
"        size that can be set by a sequence sent downline to the terminal.     "
"                                                                              "
    multiple_sizes           value = FALSE
"                                                                              "
"        Tabs_to_home is TRUE if when tabbing forward from the last            "
"        unprotected field on the screen (or backward from the first) the      "
"        cursor moves to the home position and will move to the field when     "
"        the tab key is pressed again.  Set FALSE if your terminal can tab     "
"        directly from the last unprotected field to the first (and vice       "
"        versa) or if your terminal does not support a protect attribute.      "
"                                                                              "
    tabs_to_home             value = FALSE
"                                                                              "
"        Tabs_to_tab_stops is TRUE if your terminal supports hardware          "
"        tabbing to tab stops, FALSE otherwise.                                "
"                                                                              "
    tabs_to_tab_stops        value = FALSE
"                                                                              "
"        Tabs_to_unprotected is TRUE if your terminal supports tabbing         "
"        from one unprotected field to the next (or previous).  Set to         "
"        FALSE if the terminal does not support protect or protected           "
"        tabbing.                                                              "
"                                                                              "
    tabs_to_unprotected      value = FALSE
"                                                                              "
"        Programmable_tab_stops gives the number of programmable tab stops     "
"        your terminal has allowing an application to set as many as are       "
"        available.                                                            "
"                                                                              "
    programmable_tab_stops   number = 0
"                                                                              "
"        Fixed_tab_positions is given if your terminal has tab stops that      "
"        are fixed.  The tab stop positions are given as a list of integers.   "
"                                                                              "
    fixed_tab_positions      positions = ()
"                                                                              "
"        The type_ahead directive is provided for NOS compatibility, but       "
"        is always considered to be TRUE with NOS/VE.  Type ahead means        "
"        that you do not have to wait for the system response to each          "
"        carriage return (next key) but may continue to type.  Care should     "
"        be exercised not to abuse this capability since it is possible to     "
"        produce a screen that does not reflect the actual file contents.      "
"        If you fear this is the case do a clear page or an                    "
"        ACTIVATE_SCREEN command to tell FSE to repaint the screen.            "
"                                                                              "
    type_ahead               value = TRUE
"                                                                              "
"   SCREEN SIZES                                                               "
"                                                                              "
"        The set_size statement allows setting of the terminal screen          "
"        size by specifing the number of lines and columns in a screen.        "
"        Also, if a pick/locate device is available its name and accuracy      "
"        may be specified.  If a terminal has more than one screen size        "
"        specify them in ascending order (giving columns preference over       "
"        lines) by giving the appropriate parameters for each set_size         "
"        statement.  A maximum of four sizes and a minimum of one are to       "
"        be specified.                                                         "
"                                                                              "
"        Rows is the integer number of rows (lines) on the screen for          "
"        a specific screen size.                                               "
"                                                                              "
"        Columns is the integer number of columns (characters per line)        "
"        for a specified screen size.                                          "
"                                                                              "
"        Out is the sequence to be sent to the terminal to set the             "
"        screen size. If the terminal has only one size, then specify both     "
"        rows and columns, but omit the out = () parameter entirely.           "
"                                                                              "
"        The following parameters give the name and accuracy of the            "
"        pick/locate device. For example a terminal may have a touch panel     "
"        and be accurate within a space of 4 characters by 2 lines which is    "
"        within a range of certain character positions and lines.  The         "
"        horizontal accuracy and vertical accuracy are specified with one      "
"        of two parameters.  A parameter may give the starting, ending and     "
"        increment accuracy or if the accuracy position is not consistent      "
"        use the parameter giving the actual accuracy position.                "
"                                                                              "
"        Character_specification specifies the horizontal accuracy by          "
"        giving the starting character position, ending character position     "
"        and the number of characters to increment between the possible        "
"        character positions.                                                  "
"                                                                              "
"        Character_positions specifies each cursor character position          "
"        possible for a pick/locate operation.                                 "
"                                                                              "
"        Line_specification specifies the vertical accuracy by giving the      "
"        starting line position, ending line position and the number of        "
"        lines to increment between the possible line positions.               "
"                                                                              "
"        Line_positions specifies each cursor line position possible for       "
"        a pick/locate operation.                                              "
"                                                                              "
"        Device gives a character string which names the pick/locate           "
"        device.                                                               "
"                                                                              "
    set_size       rows = 30 columns = 80   out = ()  ..
             character_specification = () line_specification = () ..
             device = ''
"                                                                              "
"   SCREEN AND LINE MODE TRANSITION                                            "
"                                                                              "
"        Set_screen_mode is the sequence that will be sent when the            "
"        terminal enters the full screen editor or a screen formatting         "
"        application.  This is where page mode should be set, tabs             "
"        perhaps cleared and so on to configure for running is screen          "
"        mode.                                                                 "
"                                                                              "
    set_screen_mode     out = ()
"                                                                              "
"        Set_line_mode is the sequence that will be sent when the              "
"        terminal exits the full screen editor or a screen formatting          "
"        application.  This is where roll (or line) should be set and          "
"        what was done by the set_screen_mode sequence reversed.               "
"                                                                              "
    set_line_mode       out = ()
"                                                                              "
"        Screen_Init and Line_Init are used in the same manner as              "
"        Set_Screen_Mode and Set_Line_Mode.  However, Screen_Init and          "
"        Line_Init may be repeated as many time as needed, each occurrence     "
"        providing no more than 256 characters, to concatenate into a string   "
"        larger than 256 characters.  The Set_Screen_Mode and Set_Line_Mode    "
"        statements cannot be repeated to construct large string.              "
"                                                                              "
    screen_init         out = ()
"                                                                              "
    line_init           out = ()
"                                                                              "
"   TERMINAL CAPABILITIES                                                      "
"                                                                              "
"        These define what capabilities such as local insert and delete        "
"   line or character your terminal provides.                                  "
"                                                                              "
"        Backspace allows you to define a key that sends a different (from     "
"        the cursor left key) sequence upline from the terminal to move        "
"        the cursor one character position to the left.  This is of            "
"        particular use if the behavior for the backspace key (which will      "
"        be treated as a character movement key, not a cursor movement key     "
"        and hence is bound by the CHARACTER MOVEMENT BEHAVIOR                 "
"        descriptions) differs from the CURSOR MOVEMENT BEHAVIOR for the       "
"        cursor_left key (as described in the CURSOR MOVEMENT BEHAVIOR         "
"        section of this file).  This is an input only sequence so the IN      "
"        keyword is used here.                                                 "
"                                                                              "
    backspace           in    = ()
"                                                                              "
"        Delete_char is the sequence for local delete character for your       "
"        terminal.  In order for this to function correctly the key that       "
"        does the local (that is on the screen) delete character must send     "
"        a sequence upline to make the full screen product aware that the      "
"        screen has changed.  This is true for all terminal capabilities.      "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    delete_char         inout = ()
"                                                                              "
"        Delete_line_bol and delete_line_stay are provided so that full        "
"        screen applications are aware of the cursor position after a          "
"        delete line function has been performed.  If your terminal has a      "
"        local delete line function then one (and only one) of                 "
"        delete_line_bol or delete_line_stay should be filled with the         "
"        correct terminal sequence.  Delete_line_bol if the cursor moves       "
"        to the leftmost position when a line is deleted, delete_line_stay     "
"        if the cursor stays in the column it was in when the delete line      "
"        function was performed.                                               "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    delete_line_bol     inout = ()
    delete_line_stay    inout = ()
"                                                                              "
"        Erase_char is the sequence for an erase character function.           "
"                                                                              "
    erase_char          inout = ()
"                                                                              "
"        Erase_end_of_line is the sequence for an erase from the current       "
"        cursor position to the end of that line.  This is not a required      "
"        terminal capability but will provide much better performance for      "
"        all full screen products.                                             "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    erase_end_of_line   inout = ()
"                                                                              "
"        Erase_field_bof is reserved for future use.                           "
"                                                                              "
    erase_field_bof     inout = ()
"                                                                              "
"        Erase_field_stay is reserved for future use.                          "
"                                                                              "
    erase_field_stay    inout = ()
"                                                                              "
"        Erase_line_bol and erase_line_stay are provided so that full          "
"        screen applications are aware of the cursor position after a          "
"        erase line function has been performed.  If your terminal has a       "
"        local erase line function then one (and only one) of                  "
"        erase_line_bol or erase_line_stay should be filled with the           "
"        correct terminal sequence.  Erase_line_bol if the cursor moves to     "
"        the leftmost position when a line is erased, erase_line_stay if       "
"        the cursor stays in the column it was in when the erase line          "
"        function was performed.                                               "
"                                                                              "
    erase_line_bol      inout = ()
    erase_line_stay     inout = ()
"                                                                              "
"        Erase_page_home and erase_page_stay are provided so that full         "
"        screen applications are aware of the cursor position after an         "
"        erase page function has been performed.  If your terminal has a       "
"        local erase page function (that sends a a sequence upline) then       "
"        one (and only one) of erase_page_home or erase_page_stay should       "
"        be filled with the correct terminal sequence.  Erase_page_home if     "
"        the cursor moves to the home position when the screen is cleared,     "
"        erase_page_stay if the cursor stays where it was when the erase       "
"        page function was performed.                                          "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    erase_page_home     inout = ()
    erase_page_stay     inout = ()
"                                                                              "
"        Insert_char is the sequence for local insert character for your       "
"        terminal.  In order for this to function correctly the key that       "
"        does the local (that is on the screen) insert character must send     "
"        a sequence upline to make the full screen product aware that the      "
"        screen has changed.  This is true for all terminal capabilities.      "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    insert_char         inout = ()
"                                                                              "
"        Insert_line_bol and insert_line_stay are provided so that full        "
"        screen applications are aware of the cursor position after a          "
"        insert line function has been performed.  If your terminal has a      "
"        local insert line function (that sends a a sequence upline) then      "
"        one (and only one) of insert_line_bol or insert_line_stay should      "
"        be filled with the correct terminal sequence.  Insert_line_bol if     "
"        the cursor moves to the leftmost position when a line is              "
"        inserted, insert_line_stay if the cursor stays in the column it       "
"        was in when the insert line function was performed.                   "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    insert_line_bol     inout = ()
    insert_line_stay    inout = ()
"                                                                              "
"        Erase_unprotected is reserved for future use.                         "
"                                                                              "
    erase_unprotected   inout = ()
"                                                                              "
"        Erase_end_of_page is reserved for future use.                         "
"                                                                              "
    erase_end_of_page   inout = ()
"                                                                              "
"        Erase_end_of_field is reserved for future use.                        "
"                                                                              "
    erase_end_of_field  inout = ()
"                                                                              "
"        Insert_mode_begin is the sequence to enter insert mode.               "
"        Characters are inserted, shifting other characters right rather       "
"        than overstriking them.                                               "
"                                                                              "
"        This statement allows an optional Label parameter.  If the label is   "
"        non-blank, this tells the system that you guarantee the key to        "
"        actually exist.  If you define the key without a label, then it will  "
"        be considered to be an optional key; if it is used then the system    "
"        will be able to recognize it, but in case it is not really available  "
"        the Editor will offer equivalent capability on one of the function    "
"        keys.  This is useful for definitions that will generically serve a   "
"        number of terminals that are similar but sometimes lack certain keys. "
"        The CDC-provided VT100 definition uses this technique.                "
"                                                                              "
    insert_mode_begin   inout = ()
"                                                                              "
"        Insert_mode_end is the sequence to exit insert mode.  Characters      "
"        will now overstrike rather than insert.                               "
"                                                                              "
    insert_mode_end     inout = ()
"                                                                              "
"        Insert_mode_toggle will switch between insert and overstike mode.     "
"        Note that if your terminal allows insert_mode_begin, then             "
"        insert_mode_end will be required.                                     "
"                                                                              "
    insert_mode_toggle  inout = ()
"                                                                              "
"        Tab_backward is the sequence sent (and received) when tabbing         "
"        from a tab stop or unprotected field to the previous tab stop or      "
"        unprotected field.                                                    "
"                                                                              "
    tab_backward        inout = ()
"                                                                              "
"        Tab_clear is the sequence to clear the tab stop at the current        "
"        cursor position.                                                      "
"                                                                              "
    tab_clear           inout = ()
"                                                                              "
"        Tab_clear_all is the sequence to clear all tab stops.                 "
"                                                                              "
    tab_clear_all       inout = ()
"                                                                              "
"        Tab_forward is the sequence sent (and received) when tabbing from     "
"        a tab stop or unprotected field to the next tab stop or               "
"        unprotected field.                                                    "
"                                                                              "
    tab_forward         inout = ()
"                                                                              "
"        Tab_set is the sequence to set a tab stop at the current cursor       "
"        position.                                                             "
"                                                                              "
    tab_set             inout = ()
"                                                                              "
"   MISCELLANEOUS TERMINAL SEQUENCES                                           "
"                                                                              "
"        Bell_nak is the sequence to ring the bell on your terminal.           "
"                                                                              "
    bell_nak            out = ()
"                                                                              "
"        Bell_ack is reserved for future use.                                  "
"                                                                              "
    bell_ack            out = ()
"                                                                              "
"        Display_begin is reserved for future use.                             "
"                                                                              "
    display_begin       out = ()
"                                                                              "
"        Display_end is reserved for future use.                               "
"                                                                              "
    display_end         out = ()
"                                                                              "
"        Field_scroll_down is reserved for future use.                         "
"                                                                              "
    field_scroll_down   out = ()
"                                                                              "
"        Field_scroll_set is reserved for future use.                          "
"                                                                              "
    field_scroll_set    out = ()
"                                                                              "
"        Field_scroll_up is reserved for future use.                           "
"                                                                              "
    field_scroll_up     out = ()
"                                                                              "
"        Output_begin is the sequence that will be sent before each stream     "
"        of output is sent downline to the terminal.  This should include      "
"        the sequence to disable protect if the terminal supports protection.  "
"                                                                              "
"        Note that with the NOS TDU facility, if your terminal provides        "
"        insert_mode_begin, then it is effectively mandatory to duplicate      "
"        the insert_mode_end sequence as output_begin.  The NOS/VE             "
"        Define_Terminal capability does not impose this requirement - it      "
"        will automatically use the the insert_mode_end sequence without       "
"        any explicit action on your part to duplicate it as output_begin,     "
"        and will correctly function if you continue the NOS technique.        "
"        But for best performance, it is advised that NOS/VE terminal          "
"        definitions should not duplicate insert_mode_end within               "
"        output_begin.                                                         "
"                                                                              "
    output_begin        out = ()
"                                                                              "
"        Output_end is the sequence that will be sent after each stream of     "
"        output (and therefore before the next request for input) is sent      "
"        downline to the terminal.  This should include the sequence to        "
"        enable protect if the terminal supports protect.                      "
"                                                                              "
    output_end          out = ()
"                                                                              "
"        Print_begin is reserved for future use.                               "
"                                                                              "
    print_begin         out = ()
"                                                                              "
"        Print_end is reserved for future use.                                 "
"                                                                              "
    print_end           out = ()
"                                                                              "
"        Print_page is reserved for future use.                                "
"                                                                              "
    print_page          out = ()
"                                                                              "
"        Protect_all is the sequence that will set the protect bit for all     "
"        characters positions on the screen.  For some terminals that have     "
"        protect this will be an empty string (an example is is a terminal     "
"        that uses a clear screen to protected character positions             "
"        sequence to accomplish this function).                                "
"                                                                              "
    protect_all         out = ()
"                                                                              "
"        Reset is reserved for future use.                                     "
"                                                                              "
    reset               out = ()
"                                                                              "
"        Return is reserved for future use.                                    "
"                                                                              "
    return              out = ()
"                                                                              "
"   PROGRAMMABLE FUNCTION KEY INPUT INFORMATION                                "
"                                                                              "
"        All full screen products use programmable function keys so that a     "
"   user can tell the full screen product what they want to do next.           "
"   Programmable function keys in the full screen editor allow a               "
"   frequently used command to be reduced to pressing the correct function     "
"   key (or required sequence of keys) for the terminal in use.                "
"                                                                              "
"        This section allows you to define what input sequences will be        "
"   sent upline by your terminal to be recognized as programmable function     "
"   keys.  The Full Screen Editor can function without any function keys,      "
"   but will provide best convenience if at least eight function keys are      "
"   available.  The Fortran/Cobol environments and the Edit_Catalog            "
"   utility require at least sixteen function keys.  Thus you should           "
"   provide for at least F1 - F16 or F1 - F8 plus F1_S - F8_S.  Note that      "
"   thirty-two function keys are possible, so you should define as many as     "
"   are practical within the constraints of your keyboard.                     "
"                                                                              "
"        The Label parameter is optional on these statements.  If it is left   "
"   out then the key is considered optional; if used it can be honored, but    "
"   no full-screen applications will depend on usage of the key for critical   "
"   operations.  If the label is non-blank, then you guarantee that the user   "
"   really has such a key on the terminal, and applications can count on it    "
"   for important operations.  The first two characters of the letter are      "
"   displayed in between function keys menus, to help the user locate the key  "
"   on the keyboard.                                                           "
"                                                                              "
    f1        in = ()        label = 'F1'
    f2        in = ()        label = 'F2'
    f3        in = ()        label = 'F3'
    f4        in = ()        label = 'F4'
    f5        in = ()        label = 'F5'
    f6        in = ()        label = 'F6'
    f7        in = ()        label = 'F7'
    f8        in = ()        label = 'F8'
    f9        in = ()        label = 'F9'
    f10       in = ()        label = 'F10'
    f11       in = ()        label = 'F11'
    f12       in = ()        label = 'F12'
    f13       in = ()        label = 'F13'
    f14       in = ()        label = 'F14'
    f15       in = ()        label = 'F15'
    f16       in = ()        label = 'F16'
    f1_s      in = ()        label = 'SF1'
    f2_s      in = ()        label = 'SF2'
    f3_s      in = ()        label = 'SF3'
    f4_s      in = ()        label = 'SF4'
    f5_s      in = ()        label = 'SF5'
    f6_s      in = ()        label = 'SF6'
    f7_s      in = ()        label = 'SF7'
    f8_s      in = ()        label = 'SF8'
    f9_s      in = ()        label = 'SF9'
    f10_s     in = ()        label = 'SF10'
    f11_s     in = ()        label = 'SF11'
    f12_s     in = ()        label = 'SF12'
    f13_s     in = ()        label = 'SF13'
    f14_s     in = ()        label = 'SF14'
    f15_s     in = ()        label = 'SF15'
    f16_s     in = ()        label = 'SF16'
"                                                                              "
"   CDC STANDARD FUNCTION KEY INPUT INFORMATION                                "
"                                                                              "
"        All full screen products use what are called CDC standard             "
"   function keys.  These are keys that have the same meaning to a             "
"   particular full screen product regardless of the terminal in use.          "
"   Each of these keys also corresponds to a physical key on the CDC 721       "
"   (Viking X) terminal, except for Undo and Undo_S.                           "
"                                                                              "
"        The next section allows you to define what input sequences the        "
"   terminal you wish to use will send upline to be recognized as CDC          "
"   standard function keys.  This capability will make all full screen         "
"   products more usable to the end user but is not required when using        "
"   the Full Screen Editor.                                                    "
"                                                                              "
"        Local screen formatting applications that have been written to        "
"   use CDC standard function keys (rather than programmable function keys     "
"   described in the previous section) to drive menus or to terminate form     "
"   type input may require that at least some CDC standard function keys       "
"   be defined in this file.                                                   "
"                                                                              "
"        If you omit these statements, then the full-screen applications will  "
"   assign the operations to function keys as defined by the statements F1     "
"   thru F16 and F1_S thru F16_S.  There is a specific default assignment      "
"   for ten of these operations, and the others are services on a first-come   "
"   basis.  You can change the default mapping by providing these statements   "
"   with IN parameters that match the IN parameters for selected function      "
"   keys.                                                                      "
"                                                                              "
    next      in = 13        label = 'RETURN'
    next_s    in = ()        label = 'Shift-NEXT'
    back      in = ()        label = 'BACK'       " default: F3         "
    back_s    in = ()        label = 'Shift-BACK'
    help      in = ()        label = 'HELP'       " default: F4         "
    help_s    in = ()        label = 'Shift-HELP'
    stop      in = ()        label = 'STOP'       " default: F6         "
    stop_s    in = ()        label = 'Shift-STOP' " default: Shift F6   "
    down      in = ()        label = 'DOWN'
    down_s    in = ()        label = 'Shift-DOWN'
    up        in = ()        label = 'UP'
    up_s      in = ()        label = 'Shift-UP'
    fwd       in = ()        label = 'FWD'        " default: F2         "
    fwd_s     in = ()        label = 'Shift-FWD'  " default: Shift F2   "
    bkw       in = ()        label = 'BKW'        " default: F1         "
    bkw_s     in = ()        label = 'Shift-BKW'  " default: Shift F1   "
    edit      in = ()        label = 'EDIT'
    edit_s    in = ()        label = 'Shift-EDIT'
    data      in = ()        label = 'DATA'
    data_s    in = ()        label = 'Shift-DATA'
"                                                                              "
"   TERMINAL VIDEO ATTRIBUTES                                                  "
"                                                                              "
"        These attributes are used mainly by screen formatting                 "
"   applications to define various types of fields (though protect_begin       "
"   and end as well as inverse_begin and end or alternate_begin and end        "
"   where they available are used by the Full Screen Editor)                   "
"                                                                              "
"        Define the attributes sequences below as described in the             "
"   hardware reference manual for your terminal.  The only restriction is      "
"   that attributes that require an actual character position on the           "
"   screen can not be used.  If your terminal has a protect mode that uses     "
"   a video attribute such as alternate video (either bright or dim) then      "
"   you will want to place these sequences in the protect_begin and            "
"   protect_end statements.  These sequences are output only hence the OUT     "
"   keyword is used here.                                                      "
"                                                                              "
"        Alt_begin is the sequence to cause subsequent characters sent         "
"        downline to be displayed in an alternate intensity (which may be      "
"        bright or dim on your terminal).                                      "
"                                                                              "
    alt_begin           out = ()
"                                                                              "
"        Alt_end is the sequence to cause subsequent characters sent           "
"        downline to be in normal intensity.                                   "
"                                                                              "
    alt_end             out = ()
"                                                                              "
"        Low_intensity_begin  is the sequence to cause subsequent              "
"        characters sent downline to be displayed in low intensity.            "
"                                                                              "
    low_intensity_begin   out = ()
"                                                                              "
"        Low_intensity_end is the sequence to cause subsequent characters      "
"        sent downline to not be displayed in low intensity.                   "
"                                                                              "
    low_intensity_end     out = ()
"                                                                              "
"        High_intensity_begin is the sequence to cause subsequent             "
"        characters sent downline to be displayed in high intensity.           "
"                                                                              "
    high_intensity_begin  out = ()
"                                                                              "
"        High_intensity_end is the sequence to cause subsequent characters     "
"        sent downline to not be displayed in high intensity.                  "
"                                                                              "
    high_intensity_end     out = ()
"                                                                              "
"        Blink_begin is the sequence to cause subsequent characters            "
"        sent downline to be displayed with a blinking attribute.              "
"                                                                              "
    blink_begin         out = ()
"                                                                              "
"        Blink_end is the sequence to cause subsequent characters              "
"        sent downline after this with not be displayed with the               "
"        blinking attribute.                                                   "
"                                                                              "
    blink_end           out = ()
"                                                                              "
"        Hidden_begin is the sequence to set the hidden attribute for          "
"        subsequent characters so that data typed in this area can not         "
"        be seen on the screen (also called a guarded attribute).              "
"                                                                              "
    hidden_begin        out = ()
"                                                                              "
"        Hidden_end is the sequence to return to visible characters.           "
"                                                                              "
    hidden_end          out = ()
"                                                                              "
"        Inverse_begin is the sequence to cause subsequent characters          "
"        to be displayed in inverse video.                                     "
"                                                                              "
    inverse_begin       out = ()
"                                                                              "
"        Inverse_end is the sequence to return to normal video.                "
"                                                                              "
    inverse_end         out = ()
"                                                                              "
"        Protect_begin is the sequence to cause subsequent characters sent     "
"        downline to the terminal to be protected, which means data can        "
"        not be typed in these character positions on the screen.              "
"                                                                              "
    protect_begin       out = ()
"                                                                              "
"        Protect_end is the sequence to return to unprotected mode.            "
"                                                                              "
    protect_end         out = ()
"                                                                              "
"        Underline_begin is the sequence to cause subsequent characters        "
"        sent downline to be displayed with an underline attribute.            "
"                                                                              "
    underline_begin     out = ()
"                                                                              "
"        Underline_end is the sequence to cause subsequent characters          "
"        sent downline to no longer be underlined.                             "
"                                                                              "
    underline_end       out = ()
"                                                                              "
"   LOGICAL ATTRIBUTE SPECIFICATIONS                                           "
"                                                                              "
"        Logical attributes are used mainly by screen formatting               "
"   applications to define various types of fields.  You are free to           "
"   equate each logical attribute with any of the standard physical            "
"   attributes or to utilize non-standard physical attributes that your        "
"   terminal might provide, but common sense is advisable.  Typically, a       "
"   'fill in the forms' application would expect you to equate the logical     "
"   'input' attribute with the physical 'underlined' attribute.  The Full      "
"   Screen Editor uses the 'italic' logical attribute for marked text -        "
"   for terminals that do not have a true italics capability it is advised     "
"   that the 'italic' logical attribute should map to the 'inverse video'      "
"   physical attribute.                                                        "
"                                                                              "
"   ERROR                                                                      "
"                                                                              "
    error_begin         out = ()
    error_end           out = ()
"                                                                              "
"   INPUT TEXT                                                                 "
"                                                                              "
"        If your terminal supports protect by use of a video attribute         "
"        such as alternate intensity for unprotected areas of the screen       "
"        you should define input_text_begin and end accordingly so that        "
"        screen formatting applications display the input fields correctly     "
"        as unprotected areas.                                                 "
"                                                                              "
    input_text_begin    out = ()
    input_text_end      out = ()
"                                                                              "
"   ITALIC                                                                     "
"                                                                              "
"        If your terminal supports an alternate character set then here is     "
"        a place that you can make use of it with screen formatting            "
"        applications.  Remember that this attribute is used by the Full       "
"        Screen Editor to emphasize marked text.                               "
"                                                                              "
    italic_begin        out = ()
    italic_end          out = ()
"                                                                              "
"   MESSAGE                                                                    "
"                                                                              "
"        Attributes display here will be used when printing help and error     "
"        messages on the first line of the screen when a screen formatting     "
"        application is running.  Use any physical attributes that you         "
"        wish but remember that if your terminal has a video attribute         "
"        based protect capability this area should be protected data.          "
"                                                                              "
    message_begin       out = ()
    message_end         out = ()
"                                                                              "
"   OUTPUT TEXT                                                                "
"                                                                              "
"        For output only data so if your terminal has a video attribute        "
"        based protect capability this area should be protected data.          "
"                                                                              "
    output_text_begin   out = ()
    output_text_end     out = ()
"                                                                              "
"   TITLE                                                                      "
"                                                                              "
    title_begin         out = ()
    title_end           out = ()
"                                                                              "
"   LINE DRAWING CHARACTER SPECIFICATION                                       "
"                                                                              "
"        Line drawing character sets that your terminal supports should be     "
"   specified here for use with the box drawing capabilty found in NOS/VE      "
"   screen formatting.  There are three line weights, fine, medium, and        "
"   bold, each with a sequence to enable and disable that weight and with      "
"   eleven characters that represent the corners, edges and intersections      "
"   for the corresponding line drawing character set.                          "
"                                                                              "
"        If your terminal has the capability of actual line drawing then       "
"   place the sequences to turn the line drawing on and off in the             "
"   ld_fine_begin, ld_fine_end and so on for up to three types of line         "
"   drawing sets (you may specify the same sequences for all three or for      "
"   any two if your terminal does not have three line drawing sets).  If       "
"   your terminal has no line drawing then the use of a hypen character        "
"   for a horizontal character, a colon or like character for a vertical       "
"   line, and asterisks for all corners and intersections is suggested.        "
"   In this case the ld_fine_begin, ld_fine_end sequences would be blank       "
"   though you could use a terminal attribute such as alternate intensity.     "
"                                                                              "
"        Also for a bold line drawing character set you can define all         "
"   characters as blanks (' ') and use inverse_on and inverse_off as the       "
"   ld_bold_begin and ld_bold_end sequences.                                   "
"                                                                              "
"        Fine Line Drawing Begin and End Sequences.                            "
"                                                                              "
    ld_fine_begin            out = ()
    ld_fine_end              out = ()
"                                                                              "
"        Horizontal and Vertical Characters.                                   "
"                                                                              "
    ld_fine_horizontal       out = ()
    ld_fine_vertical         out = ()
"                                                                              "
"        Box Corner Characters.                                                "
"                                                                              "
    ld_fine_upper_left       out = ()
    ld_fine_upper_right      out = ()
    ld_fine_lower_left       out = ()
    ld_fine_lower_right      out = ()
"                                                                              "
"        Intersection Characters.                                              "
"                                                                              "
    ld_fine_up_t             out = ()
    ld_fine_down_t           out = ()
    ld_fine_left_t           out = ()
    ld_fine_right_t          out = ()
    ld_fine_cross            out = ()
"                                                                              "
"        Medium Line Drawing Begin and End Sequences.                          "
"                                                                              "
    ld_medium_begin          out = ()
    ld_medium_end            out = ()
"                                                                              "
"        Horizontal and Vertical Characters.                                   "
"                                                                              "
    ld_medium_horizontal     out = ()
    ld_medium_vertical       out = ()
"                                                                              "
"        Box Corner Characters.                                                "
"                                                                              "
    ld_medium_upper_left     out = ()
    ld_medium_upper_right    out = ()
    ld_medium_lower_left     out = ()
    ld_medium_lower_right    out = ()
"                                                                              "
"        Intersection Characters.                                              "
"                                                                              "
    ld_medium_up_t           out = ()
    ld_medium_down_t         out = ()
    ld_medium_left_t         out = ()
    ld_medium_right_t        out = ()
    ld_medium_cross          out = ()
"                                                                              "
"        Bold Line Drawing Begin and End Sequences.                            "
"                                                                              "
    ld_bold_begin            out = ()
    ld_bold_end              out = ()
"                                                                              "
"        Horizontal and Vertical Characters.                                   "
"                                                                              "
    ld_bold_horizontal       out = ()
    ld_bold_vertical         out = ()
"                                                                              "
"        Box Corner Characters.                                                "
"                                                                              "
    ld_bold_upper_left       out = ()
    ld_bold_upper_right      out = ()
    ld_bold_lower_left       out = ()
    ld_bold_lower_right      out = ()
"                                                                              "
"        Intersection Characters.                                              "
"                                                                              "
    ld_bold_up_t             out = ()
    ld_bold_down_t           out = ()
    ld_bold_left_t           out = ()
    ld_bold_right_t          out = ()
    ld_bold_cross            out = ()
"                                                                              "
"                                                                              "
"   DEFAULT KEY DEFINITIONS FOR THE FULL SCREEN EDITOR                         "
"                                                                              "
"        The Define_Terminal facility provides a means to store arbitrary      "
"   text which can be extracted by any application.  In the case of the        "
"   Full Screen Editor, this is the means to provide default NOS/VE            "
"   commands that will associate with each function key.                       "
"                                                                              "
"        The keyword here is APPLICATION_STRING which has a 'name' and an      "
"   'out' value.  The name identifies the application for which the 'out'      "
"   string is relevant.  The application_string directive can be used as       "
"   many times as you need, but each 'out' value is limited to 256             "
"   characters and each 'name' value is limited to 31 characters.  Any         "
"   'name' can appear repeatedly.  With the Full Screen Editor, the 'name'     "
"   values are of the following format:                                        "
"                                                                              "
"        FSE_FUNCTION_1                                                        "
"        FSE_FUNCTION_SHIFT_1                                                  "
"        FSE_FUNCTION_1_LABEL                                                  "
"        FSE_FUNCTION_SHIFT_1_LABEL                                            "
"                                                                              "
"        In this example, the digit '1' indicates the function key number,     "
"   thus it could range from 1 to 16.  The word 'shift' indicates the          "
"   shifted variation of the function key, and the absence of 'shift'          "
"   indicates the unshifted key.  The presence of the word 'label' means       "
"   the 'out' value will be the label displayed on the screen to help you      "
"   remember what the key will do, and the absence of 'label' means that       "
"   the 'out' value will be the NOS/VE command string executed by the          "
"   editor when the key is pressed.  A complete example is:                    "
"                                                                              "
"        application_string name=('FSE_FUNCTION_3_LABEL') ..                   "
"          out=(' First')                                                      "
"        application_string name=('FSE_FUNCTION_SHIFT_3_LABEL') ..             "
"          out=(' Last ')                                                      "
"        application_string name=('FSE_FUNCTION_3') ..                         "
"          out=('align_screen top=first')                                      "
"        application_string name=('FSE_FUNCTION_SHIFT_3') ..                   "
"          out=('align_screen middle=last')                                    "
"                                                                              "
"        Note that the Editor contains a pre-compiled set of commands which    "
"   are matched to your function keys on a first-come basis, if you do not     "
"   provide any Application_String statements as shown in the preceeding       "
"   example.  Since it is rather tedious to construct a full set of function   "
"   key commands thru the application strings, you should first try using your "
"   terminal definition with the automatic defaults, and then add application  "
"   strings only as needed to suit your taste.                                 "
"                                                                              "
"        All screen-mode applications will also look for a few application     "
"   strings that can optimize the way output is sent to your terminal.  For    "
"   instance, some editor commands have the effect of vertically relocating    "
"   text on the screen.  If your terminal has insert/delete-line capabilities, "
"   NOS/VE can use that to scroll existing text to the correct row of the      "
"   screen.  Many terminals support the DEC VT100's "scrolling region" protcol,"
"   which can also be used for the same purpose.                               "
"                                                                              "
"        The NOS/VE screen-mode applications will paint an entire row of the   "
"   screen, by default, when any part of the row needs to be painted.  This is "
"   done to conserve CPU overhead and to support some terminals that behave    "
"   poorly when cursor motion is performed with visual highlighting in effect. "
"   Optionally, your terminal definition can request that NOS/VE optimize to   "
"   use less brute-force output.  This will usually consume more CPU overhead. "
"                                                                              "
"        To optimize horizontal re-painting, add this statement:               "
"                                                                              "
"        application_string name='optimization' out='true'                     "
"                                                                              "
"        Scrolling will be done automatically if your terminal has insert and  "
"   delete capabilities AND if you have requested optimization as shown in the "
"   previous example.  If your terminal suports the VT100 scrolling protocol,  "
"   then you can use the following statement, regardless of whether you select "
"   the optimization feature:                                                  "
"                                                                              "
"        application_string name='vt100_scrolling' out='true'                  "
"                                                                              "
"        Note that if you terminal supports both insert/delete AND the VT100   "
"   protocol, you will generally acchieve best results with the VT100 method,  "
"   as some terminals will have a side-effect with insert/delete of moving     "
"   the function keys menus temporarily out of place.                          "
"                                                                              "
"        There is another use for application strings, which is to supplement  "
"   the Screen_Init and Set_Screen_Mode statements.  Those statements define   "
"   output strings that are used at the start of each screen application.      "
"   Some terminals may require initialization to occur only once per job.  The "
"   NOS system supported this by outputing Screen_Init and Set_Screen_Mode at  "
"   different times.  Since NOS/VE outputs them together, application strings  "
"   are used as follows:                                                       "
"                                                                              "
"        application_string name='screen_init' out='text'                      "
"                                                                              "
"        Where text is up to 256 characters to be output.  You can concatenate "
"   larger strings by repeating the statement.  To utilize this definition,    "
"   your login PROLOG file should contain the following NOS/VE SCL commands:   "
"                                                                              "
"        Change_Terminal_Attributes  Terminal_Model=<name of your terminal>    "
"        Set_Program_Attributes Add_Library=<your terminal_definitions file>   "
"        Change_Interaction_Style  Screen                                      "
"        Initialize_Terminal                                                   "
"                                                                              "
"        Note that the SETPA is needed only if your definition resides in      "
"   a private library, ie, not $SYSTEM.TDU.TERMINAL_DEFINITIONS.  Note that    "
"   you can also re-initialize for line mode by using application strings named"
"   'line_init' and by using 'Line' mode on the CHAIS command.                     "
"                                                                              "
"                                                                              "
"   COMPILING YOUR TERMINAL DEFINITION                                         "
"                                                                              "
"        Now that you have completed your file you need to execute the         "
"   Define_Terminal command.  It will compile this file and produce a file     "
"   named (by default) TERMINAL_DEFINITIONS in your current working            "
"   catalog.  You test your definition by executing the command                "
"   SET_PROGRAM_ATTRIBUTES ADD_LIBRARY=TERMINAL_DEFINITIONS, then execute      "
"   the command CHANGE_TERMINAL_ATTRIBUTES TERMINAL_MODEL=XXXXX (where XXXXX   "
"   is your terminal name) and finally execute any screen oriented             "
"   application program, such as the Full Screen Editor.                       "
"                                                                              "
"        Once your terminal definition is fully debugged, you can automate     "
"   the selection of screen mode.  Make sure your TERMINAL_DEFINITIONS         "
"   file is permanent:  this is already true if you habitually set your        "
"   working catalog to $USER, but the default working catalog is $LOCAL,       "
"   in which case you should use the command COPY_FILE                         "
"   TERMINAL_DEFINITIONS $USER.TERMINAL_DEFINITIONS.  Once the file has        "
"   been made permanent, you can put the SETPA and CHATA commands (see         "
"   previous paragraph) in your login PROLOG file.                             "
"                                                                              "
"                                                                              "
"   END OF TERMINAL DEFINITION FILE FOR -------------- TERMINAL                "
