Video Systems Standard

3.4.1 Control Characters

A control character is a single character whose occurrence in a particular context initiates, modifies, or stops a control function. The control characters are referred to as C0 and C1. DEL (delete, 7/15) is also a control character, although it is not a member of the C0 or C1 sets. SP (space, 2/0) is also not a member of C0 or C1, but it may be considered to be either a control character or a graphic character.

In a 7-bit environment, the values of a C0 control character are in the range of columns 00 and 01 of the code table. The C1 control characters are represented in 7-bit environments by 2-⁠character escape sequences.

In an 8-bit environment, the values of C0 control characters are from columns 00 and 01 and the values of C1 control characters are from columns 08 and 09.

3.4.2 Graphic Characters

Graphic characters are characters other than a control character having a visual representation which is normally printed or displayed. This includes all characters from the GL and GR portions of the code table (2/1 to 7/14 inclusive and 10/1 to 15/14 inclusive for 94 character sets; 2/0 to 7/15, inclusive and 10/0 to 15/15 inclusive for 96 character sets). Graphic characters are frequently referred to as "printing characters".

Bit combinations in this same range that occur within escape or control sequences are not treated as graphic characters, but are processed as part of the control function.

5.1.1 Precedence of Control Functions

Control characters, escape sequences, control sequences, control strings, and graphic characters are processed serially in the forward direction in the data stream with the following precedence:

1. Control characters

2. Escape sequences, control sequences, and control strings (equal precedence)

3. Graphic characters

Thus, if a control character is transmitted in the middle of an escape sequence, the control character is executed as if the escape sequence were not present (that is, as if the control character had been received immediately before the escape sequence), with the exceptions noted below. The next character received is assumed to be part of the escape sequence. However, when transmitting to a device, implementors are warned not to count on this property if they wish to follow the emerging ANSI and ISO standards that specify this as an error condition whose recovery is not specified. Control characters, escape sequences, control sequences, and control strings should not (not mandatory) be embedded in other escape sequences, control sequences, or control strings.

5.1.2 Termination Conditions

Escape sequences and control sequences normally terminate only on the receipt of a valid final character. However, there are certain conditions that will cause a sequence to be terminated without valid interpretation. In all of these cases, the terminated sequence is ignored.

5.1.3 Unimplemented Functions

Unimplemented functions shall be ignored as if they were not received. This applies to unimplemented control characters, escape sequences, control sequences, parameters of control sequences, and control strings.

For example, unimplemented selective parameter values of control sequences shall be ignored as if that parameter were not received. Processing of the sequence shall continue with the next parameter. For example, if the control sequence Select Graphic Rendition (SGR) is sent with parameters: 1 (bold), 3 (italicized), 7 (negative image), and 21 (doubly underlined), and the terminal implements bold and negative image, but does not implement italicized or doubly underlined, the parameters 1 and 7 shall be executed, and 3 and 21 shall be ignored.

5.1.4 Transformation Between 7-bit and 8-bit Environments

To simplify the transformation between 7-bit and 8-bit environments, relaxations in constraints for the structure of Control Sequences (introduced by CSI), control string introducer sequences (introduced by APC, DCS, PM, and OSC), G2 sequences (introduced by SS2), and G3 sequences (introduced by SS3) are defined as follows:

In an 8-bit code, the bit combinations of columns 10 to 15 (except 15/15) are permitted to represent:

1. Parameters, intermediates, and finals of a control sequence

2. The contents of a control string introducer sequence

3. The operand of a single-shift character

In these situations, the bit combinations in the range 10/0 to 15/15 have the same meaning as the bit combinations in the corresponding row from columns 02 to 07 (bit combinations in the range 2/0 to 7/15 inclusive).

In a 7-bit code, the control characters Shift Out (SO, 0/14) and Shift In (SI, 0/15) are permitted to occur:

1. Between the Control Sequence Introducer (CSI, 9/11) and the final bit combination of a control sequence

2. Between the opening delimiter of a control string and the String Terminator (ST, 9/12)

3. Between a single-shift character and its operand

Shift Out and Shift In have no effect on the interpretation of a control sequence, a control string, or the operand of a single shift character, but may affect the meanings of sebsequent bit combinations in the data stream.

5.2.1 Expansion Escape Sequence (Fe)

An expansion escape sequence is a special 2-character escape sequence ( ESC Fe ), where Fe is in columns 04 and 05 (bit combinations from 4/0 to 5/15 inclusive). Expansion escape sequences are used to expand the 7-bit code table by being equivalent to the 8-bit C1 control code in the row in columns 08 and 09 corresponding to the row of the Fe character.

5.3.1 Parameter Values In Control Sequences

A parameter string consists of bit combinations from 3/0 to 3/15 inclusive. The string represents one or more numeric or selective parameter values. The maximum value of each parameter is defined by implementation. A minimum of 16384 decimal (14 bits) is recommended. Parameter values larger than the maximum supported by an implementation should be mapped to the largest value supported (although this is not mandatory).

The maximum number of parameters that can be contained in a single parameter string is also implementation defined; however, support for up to 16 parameters is required for compatibility. Parameters beyond the maximum number supported may be ignored.

Each parameter value consists of zero or more bit combinations from 3/0 to 3/9 inclusive, representing the decimal digits 0 to 9. If more than one parameter value is to be supplied, the parameters are separated from each other by the bit combination 3/11 (ASCII semicolon ";"). The bit combination 3/10 is reserved for future standardization. If 3/10 is received within a parameter string, the entire sequence up to and including the final character shall be ignored. Bit combinations 3/12 through 3/15 are used for private parameter strings (see subhead 3.5.3.4).

In each parameter, leading bit combinations of 3/0 are not significant and may be omitted. A zero length parameter, or one consisting only of 3/0 bit combinations, represents a default whose value depends upon the control function.

5.3.2 Numeric Parameters

Numeric parameters are used for passing numeric values. If more than one parameter value is supplied, the ordering of parameters is significant and must be preserved by the use of additional separators to replace omitted parameter values. A zero or omitted numeric parameter represents a default that can apply to that one parameter or to the entire parameter string, depending on the control function.

5.3.3 Selective Parameters

Selective parameters are used for selecting options from a list. The list of options and corresponding parameter values is defined by the control function. A control sequence with selective parameters is specified as taking either a fixed or variable number of selective parameters.

If a fixed number of selective parameters is specified, the meaning of each parameter is determined from a separate list of values or actions. All of the parameters are required (or are assumed to be defaulted) for the particular control function to take effect.

If a variable number of selective parameters is specified, each parameter selects a particular entry from a single list identified by the control.

In control sequences with a variable number of parameters, the parameters shall be processed sequentially beginning with the first parameter. A control sequence containing more than one such selective parameter shall have the same effect as a corresponding number of separate control sequences, each with a single parameter.

For example, if Select Graphic Rendition (SGR) is sent with the following parameters, the resulting rendition will be negative image, slowly blinking, since the 0 parameter, executed after setting bold and underline, would return the current rendition value to normal.

• 1 (bold)
• 4 (underlined)
• 0 (all attributes off)
• 7 (negative image)
• 5 (slowly blinking)

5.3.4 Private Parameter Strings

If a parameter string begins with a bit combination from 3/12 through 3/15, inclusive, the entire parameter string is subject to private interpretation. This means that the control has a special interpretation that is not specified in national or international standards. If bit combinations 3/12 through 3/15 occur anywhere else in the control sequence other than as the first character of the parameter string, the entire sequence up to and including the final character shall be ignored.

Syntactically, the subsequent processing of private parameter strings is identical to the processing of standard parameter strings.

5.3.5 Examples of Parameter Strings

5.4.1 Device Control Strings

The internal format of a Device Control String is:

DCS P..P I..I F D..D ST

where:

1. DCS is the Device Control String introducer.

2. P..P is an optional parameter string, identical in syntax to the parameter string of a control sequence.

3. I..I is zero or more intermediate characters in the range 2/0 to 2/15 inclusive.

4. F is a final, function defining character, in the range 7/0 to 7/14 inclusive (the same as for private Control Sequences).

5. D..D is the command string, whose format is determined by the combination of parameters, intermediate characters, and final character that precede it.

6. ST is the String Terminator control character.

5.4.2 Other Control Strings

Other control string types (Application Program Command, Operating System Command, and Privacy Message) are defined to have the following internal format.

APC I..I F D..D ST
OSC I..I F D..D ST
PM I..I F D..D ST

where:

1. APC, OSC, or PM is the Control String introducer.

2. I..I is zero or more intermediate characters in the range 2/0 to 2/15 inclusive.

3. F is a final, function defining character, in the range 3/0 to 3/15 inclusive (the same as for private Escape Sequences).

4. D..D is the command string, whose format is determined by the combination of intermediate characters and final character which precede it.

5. ST is the String Terminator control character.

5.4.3 Character Strings

Future device implementations should treat the SOS C1 control as the start of an unimplemented control string, although this is not mandatory.

A syntax is not yet specified for the interpretation of character strings; the use of SOS and character strings within Digital is reserved for future standardization. Note that ISO may define the inclusion of escape and control sequences inside Character Strings.

5.4.4 Termination Conditions

Control strings will normally terminate upon receipt of a String Terminator (9/12) character. The receipt of the control characters 0/8 through 0/13 is valid within control strings. For backward compatibility, and to minimize the effect of a lost String Terminator, the control codes CAN (1/8), SUB (1/10), ESC (1/11), or any C1 control will also terminate control strings.

Conforming software should not depend on this practice however, and shall only use the String Terminator control function to terminate a control string. Control characters other than those recognized within the command string syntax may be defined to have other meanings in the future. It is recommended that all other control codes not used within a command string be ignored by hardware.

5.4.5 GR Graphic Characters Within Control Strings

GR (8-bit) graphic characters in APC, OSC, and PM control strings will be treated as their 7-bit equivalent (the eighth bit will be ignored).

GR (8-bit) graphic characters are permitted within Device Control Strings, and the graphic character's interpretation will be dependent on the internal control string format. When they occur in the introducer sequence to a Device Control String, the eighth bit will be ignored, and they will be treated as their 7-bit equivalent. (Note that this is the same way 8-bit graphic characters are handled within control sequences.)

5.4.6 Unimplemented Control Strings

The contents of received control strings that are not implemented by the receiving party will be ignored. Therefore, all data (control and graphic characters) from the control string introducer to the string terminator (inclusive) will be discarded without being displayed.

5.5.1 C Language Source Code

/******************* module gparse.h ********************
*
* Global #include file for callable re-entrant ANSI parser.
*
* Environment:   VAX/VMS
* Author:  Peter Sichel    24-Feb-1984
*
* Modification history:
*     13-Nov-1984   P. Sichel
*         added external events for control
*         string introducers APC, OSC, and PM
*     16-May-1988   P. Sichel
*         added parse limits
*         changed default stack size to 32
*
*********************************************************/

/* parse limits */
#define MAX_NUM_INTERMEDIATES  3
#define MAX_NUM_PARAMETERS     16
#define MAX_PARAMETER_VALUE    16383

/* parse stack */
#define STACK_SIZE 32

struct parse_stack
    {
    char index;     /* stack pointer */
    unsigned char     class[STACK_SIZE];
    unsigned char     value[STACK_SIZE];
    unsigned short int data[STACK_SIZE];
    };

/* common parse states */
#define SEQ_START 0
#define CON_START 1

/* external parse events */
#define R_PARSE_ERROR   0
#define R_CONTINUE      1
#define R_GRAPHIC       2
#define R_CONTROL       3
#define R_ESC_SEQ       4
#define R_CSI_SEQ       5
#define R_DCS_SEQ       6
#define R_APC_SEQ       7
#define R_OSC_SEQ       8
#define R_PM_SEQ        9




/*   e s c a p e   s e q u e n c e   parser definitions  */
/*   (includes control character parser also)   */

/* parse states */
/*      SEQ_START 0 */    /* already defined above */
/*      CON_START 1 */    /* already defined above */
#define ES_IN_SEQ 2
#define ES_IGNORE 3



/*  c o n t r o l   s e q u e n c e   parser definitions  */

/* parse states */
/*      SEQ_START  0 */     /* already defined above */
#define CS_PRIVATE 1
#define CS_PARAM   2        /* parameter value */
#define CS_INTER   3
#define CS_IGNORE  4        /* ignore sequence,
                               but parse until final */
#define CS_IGNORE_P 5       /* ignore any further parameters,
                               but accept sequence if otherwise
                               valid */

/*********************** module lparse.h ***********************
*
*  Local #include file for callable re-entrant ANSI parser
*
*  Environment:  VAX/VMS   VAX-11 C  V1.2
*  Author:  Peter Sichel   24-Feb-1984
*
*  Modification history:
*      2-May-1984    T. Lasko
*          Fixed overlapping #define's in parser states
*      29-May-1984   P. Sichel
*          fixed pseq_parse_table to correcly
*          ignore invalid sequences
*      1-Jun-1984    P. Sichel
*          added state CS_OMIT to indicate
*          omitted parameters explicitly
*      16-May-1988   P. Sichel
*          removed CS_OMIT
*          Added CS_IGNORE_P to ignore parameters
*          beyond MAX_NUM_PARAMETERS.
*          Added ES_IGNORE to ignore escape sequences
*          with more than MAX_NUM_INTERMEDIATES.
*          Fixed bug in parse table that would accept
*          intermediates from CS_IGNORE state.
*       5-Feb-1989   P. Sichel
*          converted parse table data declaration to use
*          symbolic constants, and moved to module vtparse.c
*
****************************************************************/

/* state classes - used by parse executive to determine which
                   parser to invoke */

#define ESEQ        0        /* escape sequence   */
#define CSI         1        /* control sequence  */
#define DCS         2        /* control sequence  */
#define LAST_SEQ    2        /* "in sequence" marker */
#define CON         3        /* control and graphic characters */


/* internal parse events returned by parse_ansi() */

#define PARSE_ERROR   0x00
#define CONTINUE      0x10
#define GRAPHIC       0x20
#define CONTROL       0x30
#define ESC_SEQ       0x40
#define PAR_SEQ       0X50

#define CANCEL        0xD0
#define PARAM         0xE0    /* reduce a numeric parameter */
#define IGNORE        0xF0


/*   e s c a p e   s e q u e n c e   parser definitions  */
/*   (includes control character parser also)  */

    /* parse inputs (count by number of states) */

#define ES_CONTROL     0
#define ES_INTER       4
#define ES_FINAL       8
#define ES_GRAPHIC     12



/*   c o n t r o l   s e q u e n c e   parser definitions  */

    /* parse inputs (count by number of states) */

#define PI_CONTROL     0
#define PI_PRIVATE     6
#define PI_NUMERAL     12
#define PI_SEMICOL     18
#define PI_INTER       24
#define PI_FINAL       30
#define PI_OTHER       36

/****************** module vtparse.c ***************
*
* Callable re-entrant ANSI parser.  This module contains
* the entire parser, and the action routines that alter
* the parse state.
*
* Environment:  VAX/VMS    VAX-11 C  V1.2
*
* Author:  Peter Sichel    24-Feb-1984
*
* Modified by:
*    PAS 30-May-84  added missing "break" to switch case "IGNORE".
*    PAS 12-Nov-84  modified eseq_class and pseq_class to
*                   recognize 0xFF as a control character
*    PAS 13-Nov-84  added code to recognize OSC, PM, and APC
*                   control strings
*    PAS 16-May-88  Added code to test for MAX_NUM_INTERMEDIATES.
*                   Added code to ignore parameters beyond
*                   MAX_NUM_PARAMETERS.
*                   Added code to handle parameter values
*                   larger than MAX_PARAMETER_VALUE.
*                   Removed distinction between omitted
*                   and zero parameters.
*                   Included basic documentation in this file.
*    PAS  5-Feb-89  Included parse tables in this module.
*/


/*
Introduction To VTPARSE

VTPARSE is a table-driven, character re-entrant, callable parser
designed to recognize control functions encoded according to the
ANSI syntax for information interchange.  The rules for encoding
control functions are defined in several standards including
ANSI 3.41, DEC STD 138-0 and DEC STD 070-3.

VTPARSE accepts one input character at a time (per call), and
recognizes the following catagories of control functions when
they occur in the input stream.

      o  Graphic Characters

      o  C0 and C1 Control Characters

      o  Escape Sequences

      o  Control Sequences

      o  Control String Introducer Sequences including:
         DCS, OSC, PM, and APC

Interpreting Return Information From parse_ansi

Parse_ansi returns with "event" set to one of the following.

    R_PARSE_ERROR     parse stack overflow, or software bug
    R_CONTINUE        no event, continue parsing
    R_GRAPHIC         recognized a graphic character
    R_CONTROL         recognized a control character
    R_ESC_SEQ         recognized an escape sequence
    R_CSI_SEQ         recognized a control sequence
    R_DCS_SEQ         recognized a DCS introducer sequence
    R_OSC_SEQ         recognized a OSC introducer sequence
    R_PM_SEQ          recognized a PM  introducer sequence
    R_APC_SEQ         recognized a APC introducer sequence

The character or character sequence recognized is on the
"state" stack.  Parse_ansi returns two integers pointing to
the first and final characters of the sequence on the stack.

Each stack entry has three fields: a "class" field, a "value"
field, and a "data" field.  The possible values for these fields
are defined in the include files "gparse.h" and "lparse.h".

The "class" field is used internally by the parser to determine
which subparser to invoke (that is, the parse table to use). To
keep the tables reasonably small, a separate table is used for
parsing parameter sequences.
The "value" field is used by the parser to maintain its current
state.  The parser is a table driven finite state automata,
where the next state and action are a function of the current
state and input.  The "value" field of the parse stack provides
a history of what states the parser has been in and is useful
for interpreting the contents of the parse stack.  The "value"
field may be used to identify the contents of the "data" field
except for the final character of a sequence.  The final "value"
is usually meaningless because when a sequence is recognized,
it is removed from the stack eliminating the need for a parse
state.  A single graphic or control character is considered both
the start and final character of a sequence.

The "data" field contains the actual character data input to the
parser or a number of characters in reduced form.  Examples of
reduced forms are a single C1 control replacing an Fe sequence
or a complete parameter value replacing a number of individual
parameter characters.  Reduced forms will always be identified
by the contents of the "value" field.

Examples of typical stack data are:

             value        data
          ----------    --------
final ->  CON_START      41 'A'    event = R_GRAPHIC
                                   (the letter "A")

final ->  CON_START      0D        event = R_CONTROL
                                   (carriage return)

final ->  CON_START      41 'A'    event = R_ESC_SEQ
          ES_IN_SEQ      28 '('    (designate UK into G0)
start ->  SEQ_START      1B ESC

final ->  CS_IGNORE      68 'h'    event = R_CSI_SEQ
          CS_PARAM       3         parameter value 3
          CS_PRIVATE     3F '?'    DEC private char
start ->  SEQ_START      9B CSI    (set 132 col mode)

final ->  CS_IGNORE      72 'r'    event = R_CSI_SEQ
          CS_PARAM       14        parameter value 14(hex)
          CS_PARAM       0         zero or omitted parameter
start ->  SEQ_START      9B CSI    (set scroll region from
                                    line 1 to line 18)

final ->  CS_IGNORE      72 'p'    event = R_DCS_SEQ
start ->  SEQ_START      90 DCS    (begin REGIS DCS)

final ->  CON_START      9C ST     event = R_CONTROL
                                   (string terminator)
Errors And Exceptions

The parser ignores any invalid sequences it receives.
No control function is recognized, and the parser resynchronizes
the input stream according to the rules for error recovery in
DEC STD 138-0.




To summarize:

      o  ESC restarts any escape, control, or control string
         introducer sequence in progress.

      o  CAN and SUB immediately cancel any escape, control, or
         control string introducer sequence in progress.  SUB is
         recognized as a C0 control if no sequence is in
         progress.

      o  All other C0 controls are immediately recognized within
         escape, control, or control string introducer sequences.
         The escape, control, or control string introducer
         sequence continues where it left off.

      o  C1 controls immediately cancel any escape, control, or
         control string introducer sequence in progress.  The C1
         control is then recognized normally.  This is for 7-bit
         compatibility where C1 controls are represented by two
         character Fe escape sequences.

         Two character Fe escape sequences are converted to C1
         controls by the parser.

      o  Within escape, control, and control string introducer
         sequences, eight-bit graphic codes (GR set) are
         truncated to seven-bit codes.

      o  If a private parameter character (<, =, >, ?) occurs
         after the first parameter, the entire sequence will be
         ignored up to and including its final character.

      o  If a parameter character occurs after the first
         intermediate character, the entire sequence will be
         ignored up to and including its final character.

      o  The parser recognizes parameter values up to
         16383 (14 bits) as specified by the constant
         MAX_PARAMETER_VALUE in "gparse.h".  If a parameter
         exceeds the maximum value, the parameter will be set
         to the maximum value.

      o  The parser recognizes up to 16 parameters in a
         single parameter sequence as specified by the
         constant MAX_NUM_PARAMETERS in "gparse.h".  If more
         than MAX_NUM_PARAMETERS are received, parameters
         beyond the maximum number are ignored and the "value"
         field for the last parameter will be set to
         "CS_IGNORE_P" (this may be used to detect that
         parametershave been ignored).  The sequence will
         still be recognized if it is otherwise valid.



      o  The parser will recognize up to three intermediate
         characters in a single escape, control, or introducer
         sequence  specified by the constant MAX_NUM_INTERMEDIATES
         in "gparse.h".  If more than MAX_NUM_INTERMEDIATES are
         received, the entire sequence will be ignored up to and
         including its final character.

      o  DCS introducer sequences are parsed according to the
         rules for control sequences.  APC, OSC, and PM
         introducer sequences are parsed according to the rules
         for escape sequences.  The parser recognizes the
         introducer sequence upon receiving a valid final
         character.  The parser does not keep track of whether
         a control string is in progress.  Therefore it is
         possible to receive control codes, escape sequences,
         and control sequences within a control string.  Handling
         of control strings must be performed at a higher level
         than the parser.


Each intermediate character requires one stack entry.  Each
parameter value also requires one stack entry.  The default stack
size of 32 is sufficient to hold a sequence starting character, a
private parameter character, 16 parameters, 3 intermediates, and
still recognize nested C0 control characters.  If the maximum
number of parameters or intermediates are increased, the stack
size should be increased accordingly.  If the stack overflows,
the parser will re-initialize the stack, and return with event
PARSE_ERROR.
*/




#include "gparse.h"   /* global parse definitions */
#include "lparse.h"   /* local parse definitions */


/* escape sequence parse table */
/*  eseq_parse_table[input+from_state]  ==>  action,to_state  */

char eseq_parse_table[16] =
    {

    /* input: ES_CONTROL */
    /* from_state     action    to_state  */
    /* -----------------------------------*/
    /* SEQ_START */   CONTROL | ES_IN_SEQ,
    /* CON_START */   CONTROL | CON_START,
    /* ES_IN_SEQ */   CONTROL | ES_IN_SEQ,
    /* ES_IGNORE */   CONTROL | ES_IGNORE,

    /* input: ES_INTER   */

    /* from_state     action    to_state  */
    /* -----------------------------------*/
    /* SEQ_START */   CONTINUE | ES_IN_SEQ,
    /* CON_START */   GRAPHIC  | CON_START,
    /* ES_IN_SEQ */   CONTINUE | ES_IN_SEQ,
    /* ES_IGNORE */   IGNORE   | ES_IGNORE,

    /* input: ES_FINAL   */
    /* from_state     action    to_state  */
    /* -----------------------------------*/
    /* SEQ_START */   ESC_SEQ  | CON_START,
    /* CON_START */   GRAPHIC  | CON_START,
    /* ES_IN_SEQ */   ESC_SEQ  | CON_START,
    /* ES_IGNORE */   CANCEL   | ES_IGNORE,

    /* input: ES_GRPAHIC */
    /* from_state     action    to_state  */
    /* -----------------------------------*/
    /* SEQ_START */   PARSE_ERROR | ES_IN_SEQ,
    /* CON_START */   GRAPHIC     | CON_START,
    /* ES_IN_SEQ */   PARSE_ERROR | ES_IN_SEQ,
    /* ES_IGNORE */   PARSE_ERROR | ES_IGNORE

    };





/* control sequense parse table */
/*  pseq_parse_table[input+from_state]  ==>  action,to_state  */

char pseq_parse_table[42] =
    {
    /* input: PI_CONTROL */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    CONTROL  | CS_IGNORE,
    /* CS_PRIVATE  */    CONTROL  | CS_IGNORE,
    /* CS_PARAM    */    CONTROL  | CS_IGNORE,
    /* CS_INTER    */    CONTROL  | CS_IGNORE,
    /* CS_IGNORE   */    CONTROL  | CS_IGNORE,
    /* CS_IGNORE_P */    CONTROL  | CS_IGNORE_P,

    /* input: PI_PRIVATE */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    CONTINUE | CS_PRIVATE,
    /* CS_PRIVATE  */    CONTINUE | CS_IGNORE,
    /* CS_PARAM    */    CONTINUE | CS_IGNORE,
    /* CS_INTER    */    CONTINUE | CS_IGNORE,
    /* CS_IGNORE   */    IGNORE   | CS_IGNORE,
    /* CS_IGNORE_P */    IGNORE   | CS_IGNORE,

    /* input: PI_NUMERAL */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    PARAM    | CS_PARAM,
    /* CS_PRIVATE  */    PARAM    | CS_PARAM,
    /* CS_PARAM    */    PARAM    | CS_PARAM,
    /* CS_INTER    */    CONTINUE | CS_IGNORE,
    /* CS_IGNORE   */    IGNORE   | CS_IGNORE,
    /* CS_IGNORE_P */    IGNORE   | CS_IGNORE_P,

    /* input: PI_SEMICOL */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    PARAM    | CS_PARAM,
    /* CS_PRIVATE  */    PARAM    | CS_PARAM,
    /* CS_PARAM    */    PARAM    | CS_PARAM,
    /* CS_INTER    */    CONTINUE | CS_IGNORE,
    /* CS_IGNORE   */    IGNORE   | CS_IGNORE,
    /* CS_IGNORE_P */    IGNORE   | CS_IGNORE_P,






    /* input: PI_INTER */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    CONTINUE | CS_INTER,
    /* CS_PRIVATE  */    CONTINUE | CS_INTER,
    /* CS_PARAM    */    CONTINUE | CS_INTER,
    /* CS_INTER    */    CONTINUE | CS_INTER,
    /* CS_IGNORE   */    IGNORE   | CS_IGNORE,
    /* CS_IGNORE_P */    CONTINUE | CS_INTER,

    /* input: PI_FINAL */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    PAR_SEQ   | CS_IGNORE,
    /* CS_PRIVATE  */    PAR_SEQ   | CS_IGNORE,
    /* CS_PARAM    */    PAR_SEQ   | CS_IGNORE,
    /* CS_INTER    */    PAR_SEQ   | CS_IGNORE,
    /* CS_IGNORE   */    CANCEL    | CS_IGNORE,
    /* CS_IGNORE_P */    PAR_SEQ   | CS_IGNORE,

    /* input: PI_OTHER */
    /* from_state        action     to_state  */
    /* ---------------------------------------*/
    /* SEQ_START   */    CONTINUE | CS_IGNORE,
    /* CS_PRIVATE  */    CONTINUE | CS_IGNORE,
    /* CS_PARAM    */    CONTINUE | CS_IGNORE,
    /* CS_INTER    */    CONTINUE | CS_IGNORE,
    /* CS_IGNORE   */    IGNORE   | CS_IGNORE,
    /* CS_IGNORE_P */    CONTINUE | CS_IGNORE

    };

/* shorthand for "Stack Pointer" of parse stack */

#define SP state->index


/*************************************
*
* parse_init - initialize parse state
*
*************************************/

parse_init(state)

struct parse_stack *state;
{
    state->index = 0:
    state->class[0] = CON;
    state->value[0] = CON_START;
    return(0);
}





/*******************************************************
*
* parse_ansi - callable re-entrant ansi parser executive
*
********************************************************/

parse_ansi(c, state, event, start, final)

struct parse_stack *state;  /* address of parse stack structure */

int c;       /* input character */
int *event;  /* event recognized (by ref) */
int *start;  /* stack index of first char of event (by ref) */
int *final;  /* stack index of final char of event (by ref) */

{
int action, i;

/*..............................................*/

/* if in sequence, convert 8 bit graphics to 7 bits */
if (state->class[SP] <= LAST_SEQ)
    if (c >= 0xA0) c &= 0x7F;

/* invoke appropriate parser based on state class */
switch (state->class[SP])
    {
    case CON:
        /* parse graphic and CONtrol characters */
        action = parse(state, c, eseq_class(c), eseq_parse_table);
        break;

    case ESEQ:
        /* parse escape sequences */
        action = parse(state, c, eseq_class(c), eseq_parse_table);

        /* check for too many intermediates */
        i = 0;
        while (state->value[SP-i] == ES_IN_SEQ)
            {
            i++;
            if (i > MAX_NUM_INTERMEDIATES)
                {
                /* ignore sequence (but parse until final) */
                state->value[SP] = ES_IGNORE;
                }
            }
        break;

    case CSI:
    case DCS:
        /* parse parameter sequence */
        action = parse(state, c, pseq_class(c), pseq_parse_table);





        /* check for too many intermediates */
        i = 0;
        while (state->value[SP-i] == CS_INTER)
            {
            i++;
            if (i > MAX_NUM_INTERMEDIATES)
                {
                /* ignore sequence (but parse until final) */
                state->value[SP] = CS_IGNORE;
                }
            }
        break;
    }

/* process recognized events */
switch (action)
    {
    case CONTINUE:
        *event = R_CONTINUE;
        break;
    case GRAPHIC:
        *event = R_GRAPHIC;
        *start = SP;
        *final = SP;
        SP -= 1;
        break;
    case CONTROL:
        pcontrol(state, event, start, final);
        break;
    case ESC_SEQ:
        pescseq(state, event, start, final);
        break;
    case PAR_SEQ:
        *final = SP;
        /* find start of sequence */
        *start = SP;
        while (state->value[*start] != SEQ_START) *start -= 1;
        switch (state->data[*start])
            {
            case 0x9B: *event = R_CSI_SEQ; break;
            case 0x90: *event = R_DCS_SEQ; break;
            default:   *event = R_PARSE_ERROR; break;
            }
        /* remove seq from parse stack,
           and return to previous parser */
        SP = *start - 1;
        break;
    case PARAM:
        /* input was either a numeral, or a semicolon,
           reduce parameter chars to parameter value
           if current char is a numeral then
               if prev is a value, mul by 10, add current,
                  range check.
               else store current as a value.
           else if current is a semicolon




               store value of zero
               if prev is not a value,
               advance stack and store a value of zero.
           finally, check for too many parameters.  */
        *event = R_CONTINUE;
        i = SP;    /* remember stack pointer */
        if (state->data[SP] != 0x3B)
            {    /* numeral */
            if (state->value[SP-1] == CS_PARAM)
                {
                SP -= 1;
                if (state->data[SP] > MAX_PARAMETER_VALUE/10)
                    state->data[SP] = MAX_PARAMETER_VALUE;
                else
                    {
                    state->data[SP] *= 10;
                    state->data[SP] += state->data[SP+1] - 0x30;
                    if (state->data[SP] > MAX_PARAMETER_VALUE)
                        state->data[SP] = MAX_PARAMETER_VALUE;
                    }
                }
            else
                state->data[SP] -= 0x30;
            }
        else
            {    /* semicolon */
            state->data[SP] = 0;
            if (state->value[SP-1] != CS_PARAM)
                {
                SP += 1;
                state->class[SP] = state->class[SP-1];
                state->value[SP] = CS_PARAM;
                state->data[SP] = 0;
                }
            }
        /* check for too many parameters */
        if (SP >= i)    /* did we add a parameter? */
            {
            i = 0;
            while (state->value[SP-i] == CS_PARAM)
                {
                i++;
                if (i > MAX_NUM_PARAMETERS)
                    {
                    /* ignore last parameter */
                    SP -= 1;
                    /* ignore any further parameters */
                    state->value[SP] = CS_IGNORE_P;
                    }
                }
            }
        break;
    case CANCEL:
        if (state->class[SP] <= LAST_SEQ)
            {




            while (state->value[SP] != SEQ_START) SP -= 1;
            SP -= 1;
            }
        *event = R_CONTINUE;
        break;
    case IGNORE:
        *event = R_CONTINUE;
        SP -= 1;
        break;
    default:
        *event = R_PARSE_ERROR;
        parse_init(state);    /* re-initialize */
        break;

    }   /* end switch event */

return(*event);
}   /* end routine parse_ansi */




/*************************************************************
*
* eseq_class - return escape sequence parser input class
*              of given character.
*
**************************************************************/

eseq_class(c)
int c;
{
int c_class;
/*.....................*/

/* determine character class */
if (0x20 <= c && c <= 0x2F)
    c_class = ES_INTER;
else if ( (0x00 <= c && c <= 0x1F) ||
          (0x7F <= c && c <= 0x9F) ||
          (c == 0xFF) )
    c_class = ES_CONTROL;
else if (0x30 <= c && c <= 0x7E)
    c_class = ES_FINAL;
else
    c_class = ES_GRAPHIC;

return(c_class);
}




/*************************************************************
*
* pseq_class - return parameter sequence parser input class of
* given character.
*
**************************************************************/
pseq_class(c)
int c;
{
int pi_class;
/*.....................*/

/* determine character class */
if (0x30 <= c && c <= 0x39)
    pi_class = PI_NUMERAL;
else if (c == 0x3B)
    pi_class = PI_SEMICOL;
else if (0x20 <= c && c <= 0x2F)
    pi_class = PI_INTER;
else if (0x3C <= c && c <= 0x3F)
    pi_class = PI_PRIVATE;
else if (0x40 <= c && c <= 0x7E)
    pi_class = PI_FINAL;
else if ( (0x00 <= c && c <= 0x1F) ||
          (0x7F <= c && c <= 0x9F) ||
          (c == 0xFF) )
    pi_class = PI_CONTROL;
else
    pi_class = PI_OTHER;

return(pi_class);
}




/*******************************************
*
* parse - table driven parse routine
*
* returns the following events:
*   PARSE_ERROR
*   CONTINUE
*   GRAPHIC
*   CONTROL
*   ESC_SEQ
*   CON_SEQ
*   PARAM
*   CANCEL
*   IGNORE
*
* The parser is a table driven finite state automata,
* where the next state and action are a function of
* the current state and input.
*
*********************************************/
parse(state, c, c_class, parse_table)

struct parse_stack *state;     /*  parse stack         */
int c;                         /*  input character     */
int c_class;                   /*  input class         */
char parse_table[];            /*  parse table         */

{

int next_action;
int current_state;
int next_state;

/*...................................*/

/* get next state */
current_state = state->value[SP];
next_state = parse_table[c_class + current_state] & 0x0F;

/* get action */
next_action = parse_table[c_class + current_state] & 0xF0;

/* default action */
if (SP >= STACK_SIZE) return(PARSE_ERROR);
SP += 1;
state->class[SP] = state->class[SP-1];
state->value[SP] = next_state;
state->data[SP] = c;

/* return action */
return(next_action);

}   /* end routine parse */



/*****************************************
*
* pcontrol - process controls that alter
*            the parse state.
*
******************************************/
pcontrol(state, event, start, final)

struct parse_stack *state;
int *event;
int *start;
int *final;

{
int sp, code;
/*..................*/

sp = state->index;
code = state->data[sp];

/* ESC */
if (code == 0x1B)
    {
    /* if already in escape or control sequence, restart it */
    if (state->class[sp] <= LAST_SEQ)
        while (state->value[sp] != SEQ_START) sp -= 1;
    state->class[sp] = ESEQ;    /* switch to escape seq parser */
    state->value[sp] = SEQ_START;
    state->data[sp] = 0x1B;
    state->index = sp;
    *event = R_CONTINUE;
    return(0);
    }

/* CAN */
if (code == 0x18)
    {
    /* if already in escape or control sequence, cancel it */
    if (state->class[sp] <= LAST_SEQ)
        {
        while (state->value[sp] != SEQ_START) sp -= 1;
        }
    state->index = sp - 1;
    *event = R_CONTINUE;
    return(0);
    }

/* SUB */
if (code == 0x1A)
    {
    /* if already in escape or control sequence, cancel it */
    if (state->class[sp] <= LAST_SEQ)
        {
        while (state->value[sp] != SEQ_START) sp -= 1;
        state->index = sp-1;




        *event = R_CONTINUE;
        }
    else
        {    /* not in sequence, recognize SUB */
        *event = R_CONTROL;
        *start = sp;
        *final = sp;
        state->index = sp;
        }
    return(0);
    }


/* is it a C1 control ? */
if (code > 0x7F)
    {

    /* if already in escape or control sequence, cancel it */
    if (state->class[sp] <= LAST_SEQ)
        while (state->value[sp] != SEQ_START) sp -= 1;

    /* CSI */
    if (code == 0x9B)
        {
        /* switch to parameter seq parser */
        state->class[sp] = CSI;
        state->value[sp] = SEQ_START;
        state->data[sp] = code;
        state->index = sp;
        *event = R_CONTINUE;
        return(0);
        }

    /* DCS */
    if (code == 0x90)
        {
        /* switch to parameter seq parser */
        state->class[sp] = DCS;
        state->value[sp] = SEQ_START;
        state->data[sp] = code;
        state->index = sp;
        *event = R_CONTINUE;
        return(0);
        }



/* OSC, PM, APC */
    if ( (code == 0x9D) || (code == 0x9E) || (code == 0x9F) )
        {
        /* switch to escape sequence parser */
        state->class[sp] = ESEQ;
        state->value[sp] = SEQ_START;
        state->data[sp] = code;
        state->index = sp;
        *event = R_CONTINUE;
        return(0);
        }

    }   /* end C1 control */


/* recognize other controls */
*event = R_CONTROL;
state->data[sp] = code;
*start = sp;
*final = sp;
/* remove control character from parse stack */
state->index = sp - 1;
return(0);
}


/*************************************
*
* pescseq - process escape sequences
*           that alter the parse state.
*
**************************************/
pescseq(state, event, start, final)

struct parse_stack *state;
int *event;
int *start;
int *final;

{
int sp;
/*.....................*/

sp = state->index;

/* two character escape sequence ? */
if (state->data[sp-1] == 0x1B)
    {

    /* convert 7-bit Fe sequences to C1 controls */
    if ((0x40 <= state->data[sp]) &&  (state->data[sp] <= 0x5F))
        {
        /* store C1 control */
        state->data[sp-1] = state->data[sp] + 0x40;
        state->index = sp-1;
        /* steal code from pcontrol */
        pcontrol(state, event, start, final);
        return(0);
        }
    }

/* recognize other escape sequences */
/* find start of sequence */
while (state->value[sp] != SEQ_START) sp -= 1;
*start = sp;
*final = state->index;
switch (state->data[*start])
    {
    case 0x1B:  *event = R_ESC_SEQ; break;
    case 0x9D:  *event = R_OSC_SEQ; break;
    case 0x9E:  *event = R_PM_SEQ;  break;
    case 0x9F:  *event = R_APC_SEQ; break;
    default:    *event = R_PARSE_ERROR; break;
    }
state->index = *start - 1;   /* remove seq from parse stack */
return(0);

}   /* end routine pescseq */

/********************** module ptexec.c **************
*
* This module contains the parser test executive.
* It reads characters from the keyboard and dumps the
* parse stack when a control function is recognized.
*
* Environment:  VAX/VMS
*
* Author:  Peter Sichel    24-Feb-1984
*
* Modification history
*    8-May-1984    T. Lasko
*        Made ^Y (power off) cleaner.
*    9-MAY-1984    T. Lasko
*        Fixed several protocols.
*    13-Nov-1984   P. Sichel
*        Added OSC, PM, and APC control strings
*    9-May-1988    P. Sichel
*        Cosmetic changes for inclusion in VSRM
*/


#include <stdio.h>
#include "gparse.h"   /* global parse definitions */
#include "lparse.h"   /* local parse definitions */

/* global storage */
extern int poweron;

/* module wide storage */
struct parse_stack kbd_state;

static char *eseq_state[3] =
    {
    "SEQ_START",
    "CON_START",
    "ES_IN_SEQ"
    };
static char *pseq_state[6] =
    {
    "SEQ_START",
    "CS_PRIVATE",
    "CS_PARAM",
    "CS_INTER",
    "CS_IGNORE",
    "CS_IGNORE_P"
    };


/*******************************************
*  ptstart() -
*
*  This is the startup routine for the parser tester.
*  It simply initializes the internal state and the terminal
*  screen, then calls the executive loop, which returns when
*  we give it a ^Y (power turns off).
**********************************************/
ptstart()
{
unsigned short n;

/* erase screen, move cursor to home */
printf("\33[2J\33[H");
printf("A N S I   P a r s e r   T e s t e r\n");
printf("    Press ^Y to exit \n\n");

parse_init(&kbd_state);
poweron = 1;            /* ready....*/
set_passall();

execloop();             /* go! */

set_nopassall();
return(0);              /* when power off...return */
}


/*******************************************
*
* execloop - parser test executive
*
********************************************/
execloop()
{

int c;
int event, start, final, i;

/*..............................................*/

while (poweron)
    {

    /* get character from KEYBOARD and parse it */
    c = readkbd();

    parse_ansi(c, &kbd_state, &event, &start, &final);

    /* process recognized events */
    switch (event)
        {
        case R_CONTINUE:
            break;
        case R_GRAPHIC:
            printf("\nR_GRAPHIC:");
            ptdump(&kbd_state, start, final);
            break;
        case R_CONTROL:
            printf("\nR_CONTROL:");
            ptdump(&kbd_state, start, final);
            break;
        case R_ESC_SEQ:
            printf("\nR_ESC_SEQ:");
            ptdump(&kbd_state, start, final);
            break;
        case R_CSI_SEQ:
            printf("\nR_CSI_SEQ:");
            ptdump(&kbd_state, start, final);
            break;
        case R_DCS_SEQ:
            printf("\nR_DCS_SEQ:");
            ptdump(&kbd_state, start, final);
            break;
        case R_OSC_SEQ:
            printf("\nR_OSC_SEQ:");
            ptdump(&kbd_state, start, final);
            break;
        case R_PM_SEQ:
            printf("\nR_PM_SEQ:");
            ptdump(&kbd_state, start, final);
            break;
        case R_APC_SEQ:
            printf("\nR_APC_SEQ:");
            ptdump(&kbd_state, start, final);
            break;
        default:
            printf("\nR_PARSE_ERROR:");
            ptdump(&kbd_state, start, final);
            break;
        }   /* end switch case */

    }   /* while (poweron) */

return(0);
}   /* end routine execloop */


/**********************************
*
* ptdump - parser test stack dump
*
***********************************/
ptdump( state, start, final )

struct parse_stack *state;
int start, final;

{
int i;

for (i=start; i<=final; i++)
    {
    printf("\n    ");
    switch (state->class[i])
        {
        case ESEQ:
            printf("ESEQ %-11s", eseq_state[state->value[i]]);
            break;
        case CSI:
            printf("CSI  %-11s", pseq_state[state->value[i]]);
            break;
        case DCS:
            printf("DCS  %-11s", pseq_state[state->value[i]]);
            break;
        case CON:
            printf("CON  %-11s", eseq_state[state->value[i]]);
            break;
        default:
            printf("???      %02x    ", state->value[i]);
        }

    if (state->data[i] < 16) printf("  %02x  ", state->data[i]);
        else printf("%4x  ", state->data[i]);
    if ((0x1F < state->data[i]) && (state->data[i] < 0x7F))
        putchar((int)state->data[i]);
    }

return(0);
};

6.1.1 Locking Shifts

Conforming terminal products will provide the following locking shift functions in Level 1 operation.

Conforming terminals will provide the following additional locking shift functions in Level 2 operation.

The following bit combinations are not affected by the use of the locking shifts.

1. Those corresponding to control characters in columns 00, 01, 08, and 09

2. Those corresponding to the character Space (SP) in position 2/0, and Delete (DEL) in position 7/15 when a 94-character set is invoked into GL

3. Those corresponding to positions 10/0 and 15/15 when a 94-character set is invoked into GR

4. Those included in any escape or control sequence (see notes to subheadings 3.5.2 Escape Sequences and 3.5.3 Control Sequences for a full explanation of the use of bit combinations within escape and control sequences)

5. The bit combination following a single shift function (SS2 or SS3)

6.1.2 Single Shift Functions

Conforming terminal products will provide the following single shift functions in both 7-bit and 8-bit environments.

6.4.1 Level 1

In Level 1 operation, the default character set designations will be ASCII in G0, G1, G2, and G3. Furthermore, the G0 set (ASCII) will be invoked into the GL position of the In Use Table. Level 1 operation is 7-bits only.

6.4.2 Level 2 (without 8-bit Interface Architecture Extension)

In Level 2 operation, the default character set designations will be ASCII in G0 and G1, and the DEC Supplemental graphics set in G2 and G3. Furthermore, the G0 set (ASCII) will be invoked into the GL position of the In Use Table, and the G2 set (DEC Supplemental graphics) will be invoked into the GR position of the In Use Table.

6.4.3 Level 3 (or Level 2 with 8-bit Interface Architecture Extension)

In Level 3 operation, the default character set designations will be ASCII in G0 and G1, and the User Preference Supplemental Set (UPSS) in G2 and G3. Furthermore, the G0 set (ASCII) will be invoked into the GL position of the In Use Table, and the G2 set (UPSS, typically DEC Supplemental or ISO Latin-1 supplemental) will be invoked into the GR position of the In Use Table.

Level 3 (or Level 2 with the 8-bit Interface Architecture Extension) also recognizes the "Announce Subset Of Code Extension Facilities" defined in ISO 4873 which re-initialize the designated and invoked character sets as described later in this chapter.

6.4.4 NRCS Extension

When the NRCS Extension is present, ASCII may be replaced with a National Replacement Character set as a Set-Up option. In this case, the default character set designations will be the NRCS in G0, G1, G2, and G3, with G0 in GL. National Replacement Character Sets are intended for backward compatibility and may be used as above in Level 1, Level 2, and Level 3 by selecting "7-bit NRCS Characters" in Set-Up or setting DECNRCM (National Replacement Character set Mode) from the host. Setting this mode has the side effect of resetting the display character sets to their default state as described above. Note that the NRC Mode is 7-bits only, GR is not available. The actual NRC set used is determined by the "Keyboard Dialect", and the selection of "Typewriter" or "Data Processing" keys. See DEC STD 070-6 for more information.

7.5.1 Level 1 - Host Port

Level 1 operation provides only for 7-bit communications. Thus, in Level 1 all control and graphic characters can only be received and transmitted in seven bits. The high order bit of all 8-bit characters received will be stripped by the terminal before any processing occurs. All C1 controls will be transmitted by the terminal as ESC Fe sequences. Only 7-bit characters will be generated from the keyboard (that is, attempts to generate 8-bit characters will fail).

7.5.2 Level 2 or Level 3 - Host Port

In Level 2 or Level 3 operation both 7-bit and 8-bit communications are supported. The terminal will accept C1 control characters and GR graphic characters in both 7-bit and 8-bit C1 Transmission Modes.

When 7-bit communications is selected (7-bit host port environment), C1 controls will only be transmitted as ESC Fe sequences, and only 7-bit characters will be generated from the keyboard (that is, attempts to generate 8-bit characters on line will fail).

When 8-bit communications is selected (8-bit host port environment), the terminal can be selected to transmit C1 control characters either as 7-bit ESC Fe sequences, or as 8-bit control characters. The terminal will generate GR characters from the keyboard in eight bits.

typedef enum    /* environment_type */
    {
    SEVEN_BIT, EIGHT_BIT
    } environment_type;

environment_type
    host_port_environment,
    printer_port_environment,
    c1_transmission_mode;

Announce Subset Of Code Extension Facilities

Levels: 2X, 3 (8-bit Interface Architecture Extension)

Purpose: To indicate which subset of code extension facilities defined in ISO 4873 conforming interchange will use.

ESC     SP      <final>

1/11    2/0

Description: This sequence announces the level of conformance that the subsequent interchange will conform to. Conformance to ISO 4873 requires some default designation and invocations on the part of the terminal.

Upon receipt of a Level 1, 2, or 3 announcer sequence, the terminal will make the following designations and invocations:

• Level 1
  • ASCII is designated into G0
  • ISO Latin Alphabet Nr 1 supplemental is designated into G1
  • G0 is invoked into GL
  • G1 is invoked into GR
• Level 2
  • ASCII is designated into G0
  • ISO Latin Alphabet Nr 1 supplemental is designated into G1
  • G0 is invoked into GL
  • G1 is invoked into GR
• Level 3
  • ASCII is designated into G0
  • G0 is invoked into GL

State Affected:

• graphic_character_set_type designated_graphic_sets[4];
• graphic_character_set_type gl;
• graphic_character_set_type gr;
• gset_name_type invoked_gl;
• gset_name_type invoked_gr;

Algorithm:

void announce_level_1 ()
{
if ( (conformance_level > 2) ||
     (level_2_extensions[8bit_ia]) )
    {
    designated_graphic_sets[0] = ASCII_G;
    designated_graphic_sets[1] = ISO_LATIN1_SUPPLEMENTAL_G;
    gl = designated_graphic_sets[0];
    invoked_gl = G0;
    gr = designated_graphic_sets[1];
    invoked_gr = G1;
    }
}


void announce_level_2 ()
{
if ( (conformance_level > 2) ||
     (level_2_extensions[8bit_ia]) )
    {
    designated_graphic_sets[0] = ASCII_G;
    designated_graphic_sets[1] = ISO_LATIN1_SUPPLEMENTAL_G;
    gl = designated_graphic_sets[0];
    invoked_gl = G0;
    gr = designated_graphic_sets[1];
    invoked_gr = G1;
    }
}

void announce_level_3 ()
{
if ( (conformance_level > 2) ||
     (level_2_extensions[8bit_ia]) )
    {
    designated_graphic_sets[0] = ASCII_G;
    gl = designated_graphic_sets[0];
    invoked_gl = G0;
    }
}

Known Deviations: None

Select 7-Bit C1 Transmission — S7C1T

Levels: 2, 3

Purpose: Cause the device to generate C1 controls in 7-bits as two character ESC Fe sequences.

ESC     SP      F

1/11    2/0     4/6

Description: The S7C1T control causes the terminal to use the 7-⁠bit encoding for all C1 control characters transmitted. Therefore, all C1 characters will be represented as two character ESC Fe sequences.

Notes:

1. The coding of this control is defined in ISO and ANSI standards, but is not assigned a name in those standards.

State Affected:

• environment_type c1_transmission_mode;

Algorithm:

void select_7_bit_c1_transmission ()
{
if (conformance_level != LEVEL_1)
    c1_transmission_mode = SEVEN_BIT;
}

Known Deviations: None

Select 8-Bit C1 Transmission — S8C1T

Levels: 2, 3

Purpose: Cause the device to generate C1 controls in 8-bits as single character control codes.

ESC     SP      G

1/11    2/0     4/7

Description: The S8C1T control causes the terminal to use the 8-bit encoding for all C1 control characters transmitted. Therefore, all C1 characters will be represented as single character control codes.

Notes:

1. The coding of this control is defined in ISO and ANSI standards, but is not assigned a name in those standards.

2. If the Host_Port_environment is set to Seven_Bit, this control will be ignored by the terminal.

State Affected:

• environment_type c1_transmission_mode;

Algorithm:

void select_8_bit_c1_transmission ()
{
if ( (conformance_level != LEVEL_1) &&
     (host_port_environment == EIGHT_BIT) )
    c1_transmission_mode = EIGHT_BIT;
}

Known Deviations: None

8.3.1 Locking Shifts

LS0  (SI)

1/15

void shift_in ()
{
in_use_table.gl = designated_graphic_sets[0];
in_use_table.invoked_gl = G0;
}

LS1  (SO)

1/14

void shift_out ()
{
in_use_table.gl = designated_graphic_sets[1];
in_use_table.invoked_gl = G1;
}

ESC     n

1/11    6/14

void locking_shift_two ()
{
if (conformance_level == LEVEL_2)
    {
    in_use_table.gl = designated_graphic_sets[2];
    in_use_table.invoked_gl = G2;
    }
}

ESC     o

1/11    6/15

void locking_shift_three ()
{
if (conformance_level == LEVEL_2)
    {
    in_use_table.gl = designated_graphic_sets[3];
    in_use_table.invoked_gl = G3;
    }
}

ESC     ~

1/11    7/14

void locking_shift_one_right ()
{
if (conformance_level == LEVEL_2)
    {
    in_use_table.gr = designated_graphic_sets[1];
    in_use_table.invoked_gr = G1;
    }
}

ESC     }

1/11    7/13

void locking_shift_two_right ()
{
if (conformance_level == LEVEL_2)
    {
    in_use_table.gr = designated_graphic_sets[2];
    in_use_table.invoked_gr = G2;
    }
}

ESC     |

1/11    7/12

void locking_shift_three_right ()
{
if (conformance_level == LEVEL_2)
    {
    in_use_table.gr = designated_graphic_sets[3];
    in_use_table.invoked_gr = G3;
    }
}

8.3.2 Single Shifts

SS2

8/14

(See "Single Shift Three" below.)

SS3

8/15

/* . . . main loop */
c = readcom();

parse_ansi(c, &com_state, &event, &start, &final);

if (single_shift != NONE)
    {
    if (cancel_single_shift) single_shift = NONE;
    cancel_single_shift = IS_TRUE;
    }

/* process recognized events . . . */
if (event == R_CONTROL)
    {
    code = com_state->data[final];

    if (code == 0x0E)    /* SO (LS1) */
        {
        shift_out();
        cancel_single_shift = IS_FALSE;
        }
    else if (code == 0x0F)    /* SI (LS0) */
        {
        shift_in();
        cancel_single_shift = IS_FALSE;
        }

    else if (code == 0x8E)
        {
        single_shift = SS2;
        cancel_single_shift = IS_FALSE;
        }
    else if (code == 0x8F)
        {
        single_shift = SS3;
        cancel_single_shift = IS_FALSE;
        }
    /* . . . */
    }
/* continue main loop . . . */