# ProgressLexer.java

    // $ANTLR 2.7.7 (20060906): "progress.g" -> "ProgressLexer.java"$

    /*
    ** Module   : ProgressParser.java
    **            ProgressParserTokenTypes.java
    **            ProgressLexer.java
    ** Abstract : lex and parse Progress 4GL source code
    **
    ** Copyright (c) 2004-2024, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- --JPRM-- ----------------------------------Description-----------------------------------
    ** 001 GES 20041116   @18747 WARNING, THIS IS A GENERATED FILE!!! DO NOT EDIT THIS FILE. The original source
    **                           file is progress.g!
    */

    package com.goldencode.p2j.uast;

    import java.io.*;
    import java.util.*;
    import java.util.function.*;
    import java.util.logging.*;
    import com.goldencode.ast.*;
    import com.goldencode.p2j.schema.*;
    import com.goldencode.util.*;
    import com.goldencode.p2j.cfg.*;
    import com.goldencode.p2j.convert.*;
    import com.goldencode.p2j.preproc.*;
    import com.goldencode.p2j.util.*;
    import antlr.*;
    import antlr.debug.misc.ASTFrame;

    import java.io.InputStream;
    import antlr.TokenStreamException;
    import antlr.TokenStreamIOException;
    import antlr.TokenStreamRecognitionException;
    import antlr.CharStreamException;
    import antlr.CharStreamIOException;
    import antlr.ANTLRException;
    import java.io.Reader;
    import java.util.Hashtable;
    import antlr.CharScanner;
    import antlr.InputBuffer;
    import antlr.ByteBuffer;
    import antlr.CharBuffer;
    import antlr.Token;
    import antlr.CommonToken;
    import antlr.RecognitionException;
    import antlr.NoViableAltForCharException;
    import antlr.MismatchedCharException;
    import antlr.TokenStream;
    import antlr.ANTLRHashString;
    import antlr.LexerSharedInputState;
    import antlr.collections.impl.BitSet;
    import antlr.SemanticException;

    /**
     * Tokenizes a Progress 4GL source file (input as a stream of characters)
     * into a stream of tokens suitable for the <code>ProgressParser</code>.
     * Each token has an integer token type by which the parser references and
     * matches tokens.  This is done to make a high performance parser. To make
     * this work, the lexer must create a token object when it matches a top
     * level rule, this token object includes the token type and the actual text
     * found in the original character stream.  The lexer's main job is to
     * lookahead into the character stream, switch into the top level rule that
     * matches some set of characters and when this is complete, to create a
     * valid token object and return this to the parser.  The lexer thus
     * implements a token stream interface from the parser's perspective.
     * <p>
     * <b>Please note that this is a generated file using ANTLR 2.7.4 and a
     * grammar specified in <code>progress.g</code>.</b>
     * <p>
     * The Progress 4GL language is highly context sensitive, particularly in
     * the area of user-defined symbols and language keywords. Examples of this
     * attribute include:
     * <ul>
     *    <li> The polymorphic usage of the same language keywords for different
     *         meaning depending on which language statement is being processed.
     *    <li> The very large number of language keywords means that many or
     *         most of these must be left as unreserved keywords (the user may
     *         define symbols that hide these keywords).
     *    <li> The same symbol may appear in multiple different namespaces in
     *         the same procedure, yet these different uses are all
     *         properly differentiated.
     * </ul>
     * <p>
     * Such constructions cannot be disambiguated by looking ahead on a character
     * basis.  Instead, the context depends upon a lookahead at the token level.
     * This means that such items must be handled by the parser rather than the
     * lexer.  For this reason, the lexer is only partially able to participate
     * in the process of symbol resolution.
     * <p>
     * There are many different types of symbols.  Language keywords are the
     * most obvious symbol that are visible in all Progress 4GL source files.
     * Other types include variables, procedure names, function names, labels,
     * temp table names, etc.  All of these symbols follow the same basic
     * rules by which they are matched in the lexer, for details on this, see
     * <code>{@link #mSYMBOL}</code>.  As a result, the basic symbol rule in the
     * lexer matches all of these types and cannot set the token type properly
     * since it doesn't have enough information to do so at the time it is
     * matching.
     * <p>
     * Symbol resolution is the process by which the proper token type is
     * assigned to a token created from a match to the generic symbol rule.
     * In the lexer, the only symbol resolution that can be done is to match
     * with language keywords.  Language keywords are given preference over
     * other symbol types in any case where there is a conflict.  This is done
     * because there are significantly more locations in the parser that are
     * matching on language keywords than there are locations where a user
     * defined symbol can be in use.  Thus it makes sense to handle the conflicts
     * at the smaller number of locations in the parser, and assume that a
     * keyword match is first a keyword.  This has a great simplifying effect
     * on the parser design.  The result is selected locations in the parser
     * that override (reassign) the token type based on context.
     * <p>
     * It seems that the parser could provide feedback to the lexer at certain
     * points in its parsing.  By storing shared state with the lexer, the
     * lexer could then assign the token type properly instead of taking the
     * &quot;error on the side of keywords&quot; approach which it takes now.
     * However, due to the manner in which the parser does lookahead, this shared
     * state implementation is not possible.  The lookahead can be done at a level
     * in the parser at which the context is not yet known (outside of the rules
     * that actually handle the matching). If the lookahead depth (the
     * &quot;k&quot;) is greater than 1, then symbolic tokens (with the default
     * token type set) can be returned before the parser can set the state
     * variables that would properly control the assignment of those same
     * tokens.  <b>The decoupling of parser lookahead from the rules that know
     * enough to set the state causes it to be infeasible to implement shared
     * state between the parser and the lexer.</b>
     * <p>
     * The hundreds (thousands?) of keywords supported by Progress 4GL naturally
     * drive the use of symbol resolution and token type rewriting rather than
     * hard coding a rule for every keyword.  This is also made necessary by the
     * need to implement abbreviation support.  All of this is handled in the
     * lexer by the relatively small rule <code>mSYMBOL</code>. This efficient
     * approach to keyword processing makes the lexer significantly smaller and
     * much simpler to implement and maintain that it otherwise might have been
     * given the keyword-richness of Progress 4GL.
     * <p>
     * Other key design points:
     * <ul>
     *    <li> Progress 4GL is generally case-insensitive and for this reason
     *         this grammar has been designed to ignore case.  All symbol
     *         definitions use lowercase characters and ANTLR generates code to
     *         match both the uppercase and lowercase version of each character.
     *         This is enabled using the lexer options section.
     *    <li> The lexer is defined to create a single token of any string or
     *         comment, including nested comments (which are all provided to the
     *         parser in one single token).  All logic for matching comments and
     *         string literals (both single quoted and double quoted) is embedded
     *         in the lexer.  This <b>greatly simplifies</b> the parser since
     *         Progress allows these to be placed in such a wide range of
     *         locations (e.g. comments can be inserted anywhere in between
     *         keywords in any language statement) that it would be impossible to
     *         properly manage the state in the parser due to the essentially
     *         infinite number of permutations.
     *    <li> At the top level of the lexer, all tokens are one of the
     *         following types:
     *       <ul>
     *          <li> comments
     *          <li> string literals
     *          <li> whitespace (spaces, tabs, carriage returns, line feeds)
     *          <li> operators
     *             <ul>
     *                <li> relational
     *                <li> comparisons
     *                <li> arithmetic
     *                <li> assignment
     *                <li> precedence (parenthesis)
     *                <li> array subscripting
     *             </ul>
     *          <li> statement and parameter separators (period, colon, comma,
     *               and at sign)
     *          <li> integer and decimal literals
     *          <li> date literals
     *          <li> the unknown value
     *          <li> language keywords
     *          <li> user-defined symbols
     *          <li> filenames (relative or absolute)
     *          <li> r-code library references
     *          <li> partially or fully qualified database symbols
     *          <li> the ignore character for set/update statements (the caret)
     *          <li> tildes
     *          <li> other special characters that are invalid Progress 4GL
     *               but which may occur in arbitrary token lists used in
     *               things such as shell commands that are embedded in Progress
     *               source code (these are "unknown tokens")
     *       </ul>
     *    <li> The lexer's top level entry point is <code>nextToken</code>. This
     *         method has a for-loop that uses up to 3 characters of lookahead
     *         to identify which of the top level token rules to call. To do
     *         this, each token rule's left-most match characters are "rolled up"
     *         and tested in this top level rule.
     *    <li> Since comments and strings are at the same precedence level, each
     *         can be embedded in the other.
     *    <li> Comments and whitespace tokens are both artificially set to the
     *         special "skip" token type, which drops them from the token
     *         stream seen by the parser.  This is an important feature that
     *         simplifies the parser design.  At some future time, it is possible
     *         to capture the comments into another hidden token stream, but at
     *         this time it is not done.
     *    <li> To simplify the parser design, an assumption was made that every
     *         Progress source file comes with the dot after the last statement.
     *         Progress allows the last dot to be omitted. The lexer is
     *         responsible for injection of a fake dot character if this is the
     *         case. it is done by using a filtered input stream provided by
     *         DotKludgeStream and DotKludgeReader classes. Those classes append
     *         a dot character to the regular input if necessary thus providing
     *         a consistent input to the lexer.
     * </ul>
     * <p>
     * All token types are defined as integer constants in
     * <code>{@link ProgressParserTokenTypes}</code> which is an Interface that
     * the parser, lexer and other related classes all implement.  This allows
     * all of these classes to directly refer to the token types and share this
     * common set of definitions.  All top-level lexer rules generate a token
     * of the same name in the <code>ProgressParserTokenTypes</code> Interface.
     * There is a tokens { } section in the parser where artificial tokens are
     * defined (tokens that are not backed by a lexer rule).  These tokens are
     * also added to the <code>ProgressParserTokenTypes</code> Interface and can
     * thus be directly referenced by the lexer and parser.
     * <p>
     * Two of the most important lexer rules are {@link #mSYMBOL} and
     * {@link #mNUM_LITERAL}.  Each of these rules process highly ambiguous
     * constructs requiring a rule that recognizes multiple token types and
     * overrides the default type based on the internal matching.  Both rules
     * have to disambiguate the '.' character and the <code>mSYMBOL</code> rule
     * also has to handle the '/' character.  <b>Changes to these rules must be
     * handled with the utmost care!</b>
     * <p>
     * Due to the near total overlap between schema processing and Progress 4GL
     * source code, this lexer has been updated to support a mode with schema-
     * specific keywords such that it can lex the standard schema dump-file
     * (.df format).  The only difference is the addition of a small set of
     * schema-specific keywords that are activated by the method
     * {@link #activateSchemaProcessing}.  Once activated it cannot be removed!
     */
    public class ProgressLexer extends antlr.CharScanner implements ProgressParserTokenTypes, TokenStream
     {

       /** Logger. */
       private static final ConversionStatus LOG = ConversionStatus.get(ProgressLexer.class);

       /** Stores all keyword definitions in alphabetical order. */
       private static Keyword[] keywords = null;

       /** Stores all ignored keyword definitions. */
       private static Keyword[] ignored = null;

       /** Debug mode, defaults to <code>false</code>. */
       private boolean debug = false;

       /** Schema mode, defaults to <code>false</code>. */
       private boolean schema = false;

       /** Export mode, defaults to <code>false</code>. */
       private boolean export = false;

       /** Hidden mode, defaults to <code>false</code>. */
       private boolean hidden = false;

       /** Raw string processing mode, defaults to <code>false</code>. */
       private boolean raw = false;

       /** Honor backslashes as escape characters. */
       private boolean unixEscapes = true;

       /**
        * Allow slash-slash style comments (started in v11, older code can have unquoted filenames
        * that include this same construct and will break parsing.
        */
       private boolean allowSlashSlash = true;

       /**
        * Enables language keyword resolution.  This instance is shared with the
        * parser but no real time state sharing is done.
        */
       private SymbolResolver sym = null;

       /**
        * Creates a <code>Keyword</code> array and initializes that array to
        * the list of all recognized Progress 4GL language keywords. The
        * initialization is done in-line and the source file is organized in
        * an easy to maintain column format.
        * <p>
        * The following values are needed for each <code>Keyword</code> object:
        * <ul>
        *    <li> full keyword text for the keyword
        *    <li> the minimum number of characters for matching ( > 0 means that
        *         abbreviations are possible, 0 means no abbreviations)
        *    <li> the integer token type to assign to the keyword on a match
        *         (see below)
        *    <li> whether it is a reserved keyword or not (true means it is
        *         reserved)
        * </ul>
        * <p>
        * See <code>{@link Keyword}</code> for more details.
        * <p>
        * The core idea here is to populate a facility where the symbol text (in
        * the mSYMBOL method) can be submitted to the keyword dictionary for a
        * lookup. If a match is found, then the token type of the token is set
        * based on the token type field in the <code>Keyword</code> object
        * found in the dictionary.  This returned token type will override the
        * default token type of <code>SYMBOL</code>.  Since all of these keywords
        * are not encoded in the matching rules of the grammar itself, there are
        * no actual token definitions in the lexer that match these keywords.
        * For this reason, we take advantage of the feature in the parser in
        * which we can create (reserve) a unique integer value and associate it
        * with a specific artificial token name (e.g. KW_DEFINE).  These
        * artificial token types are used as the values when constructing
        * <code>Keyword</code> objects.
        * <p>
        * When adding <code>Keyword</code> objects to this array, make sure to
        * add the associated artificial token type to the tokens { } section
        * of the parser.
        * <p>
        * Some entries have inherent conflicts due to ambiguity in the Progress
        * language.  For example, <code>WIDTH</code> and <code>WIDTH-CHARS</code>
        * can both be abbreviated as <code>WIDTH</code> even though they are
        * used for completely separate purposes and are described as separate
        * keywords.  Of course, one cannot use <code>WIDTH-</code> or
        * <code>WIDTH-C</code> etc as a replacement for <code>WIDTH</code>. So
        * these really are 2 different keywords but there are fixups inside
        * Progress that makes it tolerant of this issue.  In our case, we detect
        * these possible overlaps in the parser and rewrite the token to the
        * expected version so that downstream processing is easier.  In this
        * list, some changes have been made to ensure that conflicts don't
        * occur (e.g. <code>WIDTH-CHARS</code> is stated to have a minimum
        * abbreviation of 6 chars instead of the correct value of 5).
        * <p>
        * The following keywords exist in the keyword list but they have no
        * references in the parser.  There are two reasons for this. First,
        * some of the keywords are used for stored procedure support which is
        * currently incomplete in the parser.  When that support is completed,
        * these keywords should be removed from this list.  Second, there are
        * several keywords which are listed in the keyword index and in the notes
        * their purpose is stated.  However, no other reference to these keywords
        * exists in the language reference.  So these are listed as "possible
        * undocumented ..." features.  In this case, when there is enough
        * information available to determine how they must be supported, those
        * changes to the parser can be made and the tokens should then be removed
        * from this list.
        * <pre>
        *                                        Exists
        *                                        in 4GL
        *                                        Keyword
        * Keyword Text              Token        Index    Issue
        * ------------------------  -----------  -------  ----------------------------------------------------------------------
        * CLOSEALLPROCS             KW_CLOSE_AP  no       special stored-procedure-related name, not fully implemented in parser
        * MARGIN-HEIGHT-CHARS       KW_MARG_H_C  yes      possible undocumented attribute
        * MARGIN-HEIGHT-PIXELS      KW_MARG_H_P  yes      possible undocumented attribute
        * MARGIN-WIDTH-CHARS        KW_MARG_W_C  yes      possible undocumented attribute
        * MARGIN-WIDTH-PIXELS       KW_MARG_W_P  yes      possible undocumented attribute
        * OCTET-LENGTH              KW_OCT_LEN   yes      possible undocumented FIND option
        * PROC-TEXT                 KW_PROC_TXT  yes      special stored-procedure-related name, not fully implemented in parser
        * PROC-TEXT-BUFFER          KW_PROC_T_B  yes      special stored-procedure-related name, not fully implemented in parser
        * RULE-Y                    KW_RULE_Y    yes      possible undocumented attribute
        * SCROLL-DELTA              KW_SCR_DELT  yes      possible undocumented attribute
        * SCROLL-OFFSET             KW_SCR_OFFS  yes      possible undocumented attribute
        * SCROLLED-ROW-POSITION     KW_SCR_RPOS  yes      possible undocumented attribute
        * SEND-SQL-STATEMENT        KW_SEND_SQL  yes      special stored-procedure-related name, not fully implemented in parser
        * TRAILING                  KW_TRAILING  yes      possible undocumented built-in function and option for FOR/DO/REPEAT
        * </pre>
        * <p>
        * In addition to the above keywords, there are many other keywords that
        * may appear in the keyword list below, but which are not otherwise
        * referenced.  There are 3 common reasons for this:
        * <ul>
        *   <li> an event name will be used as the <code>oldtype</code>
        *        annotation of an EVENT node
        *   <li> an constant name may be used in certain built-in functions or
        *        method calls
        *   <li> an built-in function (or built-in global variable) name will be
        *        used as the <code>oldtype</code> annotation
        * </ul>
        * There is no problem with the parser/lexer in this regard.  Do not be
        * concerned!
        * <p>
        * With this noted, there are some cases where the keyword list appears
        * to be missing some keywords that are listed in the Progress 4GL Language
        * Reference Keyword Index.
        * <p>
        * The most common case is a "duplicated" keyword that is really a synonym
        * for another longer keyword.  The longer keyword has an abbreviation
        * which makes it match the same text as the shorter keyword.  From the
        * Progress compiler's perspective both forms are treated the same. This
        * is different from the <code>WIDTH</code> and <code>WIDTH-</code> case
        * noted above, since in that case the keywords are not synonyms. In
        * the duplicate case, the shorter keyword is considered a duplicate of
        * the longer one. WE ALWAYS INCLUDE THE LONGER KEYWORD WITH ITS
        * ABBREVIATION AND THE SHORT KEYWORD IS NOT NEEDED BECAUSE IT IS HANDLED
        * BY THE OTHER ONE THAT IS ALREADY THERE.  In other words, this short
        * keyword never needs to be added to the keyword list because the support
        * is already sufficient.  It is unknown why Progress documented "both"
        * keywords, because the longer one covers both usages.  In all such cases
        * the short keyword will be missing and that is OK! Here is the list:
        * <p>
        * <pre>
        * Short Keyword Text  Long Keyword Text    Abbreviation
        * ------------------  -------------------- ------------
        * ACCUM               ACCUMULATE           5
        * ASC                 ASCENDING            3
        * BUTTON              BUTTONS              6
        * DESC                DESCENDING           4
        * FIELD               FIELDS               5
        * FORM                FORMAT               4
        * FORWARD             FORWARDS             7
        * MAX                 MAXIMUM              3
        * MIN                 MINIMUM              3
        * REPOSITION-BACKWARD REPOSITION-BACKWARDS 19
        * REPOSITION-FORWARD  REPOSITION-FORWARDS  18
        * </pre>
        * <p>
        * The following are keywords that are documented in the Progress 4GL
        * Language Reference Keyword Index but which are not really language
        * keywords at all:
        * <p>
        * <ul>
        *    <li><code>DEFINED</code> - this is a symbol that is a preprocessor
        *        function but it is not something that has any meaning in a 4GL
        *        program so the parser should not have any knowledge of it
        *    <li><code>ENABLED-FIELDS</code> - the keyword index displays this as
        *        "ENABLED-FIELDS" (with the double quotes) and this is noted as
        *        an option to the validate() method; testing has shown that this
        *        is a string literal NOT a real keyword (if you take the double
        *        quotes away you get a compiler error so this is not really a
        *        keyword)
        *    <li><code>SET-CURRENT-VALUE</code> - this is a possible value
        *        returned inside a string from the <code>DBRESTRICTIONS</code>
        *        built-in function but this can't appear in directly (unquoted)
        *        in 4GL source so this is NOT a real keyword
        * </ul>
        * <p>
        * Progress is so over-the-top keyword intensive that they sometimes have
        * multiple forms of the same keyword (e.g. USER and USERID, WAIT and
        * WAIT-FOR, GETBYTE and GET-BYTE). These are not abbreviations but just
        * synonyms that require separate entries in the keyword index. The key
        * point is that they will both resolve to the same token type (e.g.
        * WAIT and WAIT-FOR both resolve to KW_WAIT_FOR). The order of these
        * in the list will determine what "standard text" will be found when
        * using a reverse text lookup (lookup of the text for a keyword based on
        * its token type). In particular, the LAST entry to be added will be the
        * "canonical" text returned from a reverse lookup. This affects reports
        * and other features. Always order these with the most common form of
        * the keyword as the last entry in the keyword index. So WAIT-FOR must
        * follow WAIT in the list to ensure that the reverse lookup of
        * KW_WAIT_FOR would return the text WAIT-FOR instead of WAIT.
        */
       static
       {
          keywords = new Keyword[]
          {
             /* format:  Full Keyword Text (lowercased)    Abr  Token Type   Reserved */
             new Keyword("_polymorphic_"                  ,  0, KW_POLY    , false),  // FWD extension, not real 4GL!
             new Keyword("_cbit"                          ,  0, KW_CBIT    , false),  // undocumented
             new Keyword("_control"                       ,  0, KW_U_CTRL  , true ),  // undocumented
             new Keyword("_msg"                           ,  0, KW_U_MSG   , true ),  // undocumented
             new Keyword("_pcontrol"                      ,  0, KW_U_PCTRL , true ),  // undocumented
             new Keyword("_serial-num"                    ,  7, KW_U_SERIAL, true ),  // undocumented
             new Keyword("abort"                          ,  0, KW_ABORT   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("absolute"                       ,  3, KW_ABS     , false),
             new Keyword("abstract"                       ,  0, KW_ABSTRACT, false),
             new Keyword("accelerator"                    ,  0, KW_ACCEL   , false),
             new Keyword("accept-changes"                 ,  0, KW_ACC_CHG , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("accept-row-changes"             ,  0, KW_ACC_RCHG, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("accumulate"                     ,  5, KW_ACCUM   , true ),  // handles "separate keyword" accum too
             new Keyword("activate"                       ,  0, KW_ACTIVATE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("active"                         ,  0, KW_ACTIVE  , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("active-form"                    ,  0, KW_ACT_FORM, true ),
             new Keyword("active-window"                  ,  0, KW_ACT_WIN , true ),
             new Keyword("actor"                          ,  0, KW_ACTOR   , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("add"                            ,  0, KW_ADD     , true ),
             new Keyword("add-bcc-address"                ,  0, KW_ADD_BCCA, false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-buffer"                     ,  0, KW_ADD_BUF , false),
             new Keyword("add-calc-column"                ,  0, KW_ADD_C_C , false),
             new Keyword("add-cc-address"                 ,  0, KW_ADD_CC_A, false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-chart"                      ,  0, KW_RPT_ADDC, false),  // FWD extension, not real 4GL; export Jasper report to csv
             new Keyword("add-child-node"                 ,  0, KW_ADD_C_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-columns-from"               ,  0, KW_ADD_C_F , false),
             new Keyword("add-events-procedure"           ,  0, KW_ADD_EVTP, false),
             new Keyword("add-fields-from"                ,  0, KW_ADD_F_F , false),
             new Keyword("add-first"                      ,  0, KW_ADD_1ST , false),
             new Keyword("add-first-node"                 ,  0, KW_ADD_F_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-header-entry"               ,  0, KW_ADD_HENT, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("add-image"                      ,  0, KW_ADD_IMG , false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-index-field"                ,  0, KW_ADD_IDXF, false),
             new Keyword("add-interval"                   ,  0, KW_ADD_INVL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("add-last"                       ,  0, KW_ADD_LAST, false),
             new Keyword("add-last-node"                  ,  0, KW_ADD_L_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-like-column"                ,  0, KW_ADD_L_C , false),
             new Keyword("add-like-field"                 ,  0, KW_ADD_LIKF, false),
             new Keyword("add-like-index"                 ,  0, KW_ADD_LIKI, false),
             new Keyword("add-new-field"                  ,  0, KW_ADD_NEWF, false),
             new Keyword("add-new-index"                  ,  0, KW_ADD_NEWI, false),
             new Keyword("add-next-node"                  ,  0, KW_ADD_N_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-parent-id-relation"         ,  0, KW_ADD_PREL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("add-relation"                   ,  0, KW_ADD_REL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("add-schema-location"            ,  0, KW_ADD_SLOC, false),
             new Keyword("add-source-buffer"              ,  0, KW_ADD_SRCB, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("add-super-procedure"            , 14, KW_ADD_SUP , false),  // undocumented abbreviation (keyword is in the 4GL keyword index but no abbreviation is listed)
             new Keyword("add-tab"                        ,  0, KW_ADD_TAB , false),  // FWD extension, not a real 4GL keyword
             new Keyword("add-to-address"                 ,  0, KW_ADD_TO_A, false),  // FWD extension, not a real 4GL keyword
             new Keyword("adm-data"                       ,  0, KW_ADM_DATA, false),
             new Keyword("adm-timing-out"                 ,  0, KW_ADM_TO  , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("advise"                         ,  0, KW_ADVISE  , false),
             new Keyword("after-buffer"                   ,  0, KW_AFT_BUFF, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("after-fill"                     ,  0, KW_AFT_FILL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("after-label-edit"               ,  0, KW_N_AEDIT , false),  // FWD extension, not a real 4GL keyword
             new Keyword("after-row-fill"                 ,  0, KW_AFT_R_F , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("after-rowid"                    ,  0, KW_AFT_ROID, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("after-table"                    ,  0, KW_AFT_TBL , false),
             new Keyword("alert-box"                      ,  0, KW_ALERT_BX, false),
             new Keyword("alias"                          ,  0, KW_ALIAS   , true ),
             new Keyword("alignment"                      ,  0, KW_ALIGN   , false),  // FWD extension, not a real 4GL keyword
             new Keyword("all"                            ,  0, KW_ALL     , true ),
             new Keyword("allow-column-searching"         ,  0, KW_ALLW_C_S, false),
             new Keyword("allow-replication"              ,  0, KW_ALLW_REP, false),
             new Keyword("alter"                          ,  0, KW_ALTER   , true ),
             new Keyword("alternate-key"                  ,  0, KW_ALT_KEY , false),
             new Keyword("always-on-top"                  ,  0, KW_ALW_ON_T, false),
             new Keyword("ambiguous"                      ,  5, KW_AMBIG   , true ),
             new Keyword("analyze"                        ,  6, KW_ANALYZ  , true ),  // totally undocumented
             new Keyword("and"                            ,  0, KW_AND     , true ),
             new Keyword("ansi-only"                      ,  0, KW_ANSI_ONL, false),
             new Keyword("any"                            ,  0, KW_ANY     , true ),
             new Keyword("any-key"                        ,  0, KW_ANY_KEY , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("any-printable"                  ,  0, KW_ANY_PRT , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("anywhere"                       ,  0, KW_ANYWHERE, false),
             new Keyword("append"                         ,  0, KW_APPEND  , false),
             new Keyword("append-child"                   ,  0, KW_APPEND_C, false),
             new Keyword("append-line"                    ,  0, KW_APPEND_L, false),  // missing in keyword index, found in customer source
             new Keyword("appl-alert-boxes"               , 10, KW_APPL_A_B, false),
             new Keyword("appl-context-id"                ,  0, KW_APPL_CID, false),
             new Keyword("application"                    ,  0, KW_APPL    , false),
             new Keyword("apply"                          ,  0, KW_APPLY   , true ),
             new Keyword("apply-callback"                 ,  0, KW_APPL_CBK, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("appserver-info"                 ,  0, KW_APP_INFO, false),
             new Keyword("appserver-password"             ,  0, KW_APP_PW  , false),
             new Keyword("appserver-userid"               ,  0, KW_APP_UID , false),
             new Keyword("array-message"                  ,  0, KW_ARR_MSG , false),
             new Keyword("as"                             ,  0, KW_AS      , true ),
             new Keyword("as-thread"                      ,  0, KW_AS_THRD , false),  // FWD extension, not a real 4GL keyword
             new Keyword("ascending"                      ,  3, KW_ASC     , true ),  // ASC is documented as a separate non-reserved keyword, but in fact it is reserved AND ASCENDING can be used as a complete synonym
             new Keyword("asciitohtml"                    ,  0, KW_ASCII_2H, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("ask-overwrite"                  ,  0, KW_ASK_OVER, false),
             new Keyword("assembly"                       ,  0, KW_ASSEMBLY, false),
             new Keyword("assign"                         ,  0, KW_ASSIGN  , true ),
             new Keyword("asterisk-active"                ,  0, KW_AST_ACTI, false),  // FWD extension, not a real 4GL keyword
             new Keyword("asynchronous"                   ,  0, KW_ASYNC   , true ),
             new Keyword("async-request-count"            ,  0, KW_ASYNC_RC, false),
             new Keyword("async-request-handle"           ,  0, KW_ASYNC_RH, false),
             new Keyword("at"                             ,  0, KW_AT      , true ),
             new Keyword("at-web-browser"                 ,  0, KW_AT_W_BRW, false),  // FWD extension, not a real 4GL keyword
             new Keyword("attach-data-source"             ,  0, KW_ATT_DSRC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("attach-file"                    ,  0, KW_ATT_FILE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("attach-url"                     ,  0, KW_ATT_URL , false),  // FWD extension, not a real 4GL keyword
             new Keyword("attached-pairlist"              ,  0, KW_ATT_PLST, false),
             new Keyword("attr-space"                     ,  4, KW_ATTR    , true ),
             new Keyword("attribute-names"                ,  0, KW_ATTR_NAM, false),
             new Keyword("audit-control"                  ,  0, KW_AUD_CTRL, true ),
             new Keyword("audit-enabled"                  ,  0, KW_AUD_ENAB, false),
             new Keyword("audit-event-context"            ,  0, KW_AUD_EV_C, false),
             new Keyword("audit-policy"                   ,  0, KW_AUD_POL , true ),
             new Keyword("auth-blob"                      ,  0, KW_AUTHBLOB, false),  // FWD extension, not a real 4GL keyword
             new Keyword("authentication-failed"          ,  0, KW_AUTHEN_F, false),
             new Keyword("authorization"                  ,  0, KW_AUTHORZN, true ),
             new Keyword("auto-completion"                ,  9, KW_AUTO_COM, false),
             new Keyword("auto-delete"                    ,  0, KW_AUTO_DEL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("auto-delete-xml"                ,  0, KW_AUTO_D_X, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("auto-end-key"                   ,  0, KW_AUTO_END, false),
             new Keyword("auto-endkey"                    ,  0, KW_AUTO_END, false),
             new Keyword("auto-go"                        ,  0, KW_AUTO_GO , false),
             new Keyword("auto-indent"                    ,  8, KW_AUTO_IND, false),
             new Keyword("auto-resize"                    ,  0, KW_AUTO_RES, false),
             new Keyword("auto-return"                    ,  8, KW_AUTO_RET, true ),
             new Keyword("auto-synchronize"               ,  0, KW_AUTO_SYN, false),
             new Keyword("auto-validate"                  ,  8, KW_AUTO_VAL, false),
             new Keyword("auto-zap"                       ,  6, KW_AUTO_ZAP, false),
             new Keyword("automatic"                      ,  0, KW_AUTOMATC, false),
             new Keyword("available"                      ,  5, KW_AVAIL   , true ),
             new Keyword("available-formats"              ,  0, KW_AVL_FMTS, false),
             new Keyword("available-messages"             ,  0, KW_AVL_MSGS, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("average"                        ,  3, KW_AVERAGE , false),
             new Keyword("avg"                            ,  0, KW_AVG     , false),
             new Keyword("background"                     ,  4, KW_BACKGRND, true ),
             new Keyword("backspace"                      ,  0, KW_BACKSP  , false),
             new Keyword("backwards"                      ,  8, KW_BACKWARD, false),
             new Keyword("back-tab"                       ,  0, KW_BACK_TAB, false),
             new Keyword("basic-logging"                  ,  0, KW_BAS_LOGG, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("base64-decode"                  ,  0, KW_BASE64_D, false),
             new Keyword("base64-encode"                  ,  0, KW_BASE64_E, false),
             new Keyword("base-ade"                       ,  0, KW_BASE_ADE, false),
             new Keyword("base-key"                       ,  0, KW_BASE_KEY, false),
             new Keyword("batch-mode"                     ,  5, KW_BATCH_MO, false),
             new Keyword("batch-size"                     ,  0, KW_BATCH_SZ, false),
             new Keyword("before-buffer"                  ,  0, KW_B4_BUFF , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("before-fill"                    ,  0, KW_B4_FILL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("before-hide"                    ,  8, KW_B4_HIDE , true ),
             new Keyword("before-label-edit"              ,  0, KW_N_BEDIT , false),  // FWD extension, not a real 4GL keyword
             new Keyword("before-row-fill"                ,  0, KW_B4_R_F  , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("before-rowid"                   ,  0, KW_B4_ROWID, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("before-table"                   ,  0, KW_B4_TABLE, false),
             new Keyword("begin-event-group"              ,  0, KW_BEG_EV_G, false),
             new Keyword("begins"                         ,  0, KW_BEGINS  , true ),
             new Keyword("bell"                           ,  0, KW_BELL    , true ),
             new Keyword("between"                        ,  0, KW_BETWEEN , true ),
             new Keyword("bgcolor"                        ,  3, KW_BGCOLOR , false),
             new Keyword("bgcolor-rgb"                    ,  0, KW_BGCOLRGB, false),  // FWD extension, not real 4GL!
             new Keyword("big-endian"                     ,  0, KW_B_ENDIAN, true ),
             new Keyword("binary"                         ,  0, KW_BINARY  , false),
             new Keyword("bind"                           ,  0, KW_BIND    , false),
             new Keyword("bind-where"                     ,  0, KW_BIND_WH , false),
             new Keyword("blank"                          ,  0, KW_BLANK   , true ),
             new Keyword("blob"                           ,  0, KW_BLOB    , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("block"                          ,  0, KW_BLOCK   , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("block-iteration-display"        ,  0, KW_BLK_IT_D, false),
             new Keyword("block-level"                    ,  9, KW_BLK_LVL , false),
             new Keyword("border-bottom-chars"            ,  8, KW_BORD_B_C, false),
             new Keyword("border-bottom-pixels"           , 15, KW_BORD_B_P, false),
             new Keyword("border-left-chars"              ,  8, KW_BORD_L_C, false),
             new Keyword("border-left-pixels"             , 13, KW_BORD_L_P, false),
             new Keyword("border-right-chars"             ,  8, KW_BORD_R_C, false),
             new Keyword("border-right-pixels"            , 14, KW_BORD_R_P, false),
             new Keyword("border-top-chars"               ,  8, KW_BORD_T_C, false),
             new Keyword("border-top-pixels"              , 12, KW_BORD_T_P, false),
             new Keyword("both"                           ,  0, KW_BOTH    , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("bottom"                         ,  0, KW_BOTTOM  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("bottom-column"                  ,  0, KW_BOTTOM_C, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("box"                            ,  0, KW_BOX     , false),
             new Keyword("box-selectable"                 , 10, KW_BOX_SEL , false),
             new Keyword("break"                          ,  0, KW_BREAK   , true ),
             new Keyword("break-line"                     ,  0, KW_BREAK_L , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("browse"                         ,  0, KW_BROWSE  , false),
             new Keyword("browser-external-ip"            ,  0, KW_BR_IP   , false),  // FWD extension, not a real 4GL keyword
             new Keyword("browser-port"                   ,  0, KW_BR_PORT , false),  // FWD extension, not a real 4GL keyword
             new Keyword("browser-timezone"               ,  0, KW_BR_TZ   , false),  // FWD extension, not a real 4GL keyword
             new Keyword("btos"                           ,  0, KW_BTOS    , true ),  // undocumented
             new Keyword("buffer"                         ,  0, KW_BUFFER  , false),
             new Keyword("buffer-chars"                   ,  0, KW_BUFFER_C, false),
             new Keyword("buffer-compare"                 , 11, KW_BUF_COMP, true ),  // this is reserved and has an abbreviation even though the documentation states it should be otherwise
             new Keyword("buffer-copy"                    ,  0, KW_BUF_COPY, true ),  // this is reserved even though the documentation states it should be otherwise
             new Keyword("buffer-create"                  ,  0, KW_BUF_CREA, false),
             new Keyword("buffer-delete"                  ,  0, KW_BUF_DEL , false),
             new Keyword("buffer-field"                   ,  0, KW_BUF_FLD , false),
             new Keyword("buffer-group-id"                ,  0, KW_BUF_GRPI, false),  // missing in keyword index, found elsewhere in lang ref, untested at this time
             new Keyword("buffer-group-name"              ,  0, KW_BUF_GRPN, false),  // missing in keyword index, found elsewhere in lang ref, untested at this time
             new Keyword("buffer-handle"                  ,  0, KW_BUF_HNDL, false),
             new Keyword("buffer-lines"                   ,  0, KW_BUFFER_L, false),
             new Keyword("buffer-name"                    ,  0, KW_BUF_NAME, false),
             new Keyword("buffer-partition-id"            ,  0, KW_BUF_PARI, false),
             new Keyword("buffer-release"                 ,  0, KW_BUF_REL , false),
             new Keyword("buffer-tenant-id"               ,  0, KW_BUF_TENI, false),  // missing in keyword index, found elsewhere in lang ref, untested at this time
             new Keyword("buffer-tenant-name"             ,  0, KW_BUF_TENN, false),  // missing in keyword index, found elsewhere in lang ref, untested at this time
             new Keyword("buffer-validate"                ,  0, KW_BUF_VLID, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("buffer-value"                   ,  0, KW_BUF_VAL , false),
             new Keyword("building-tree"                  ,  0, KW_BUILD_TR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("button-list"                    ,  0, KW_BTN_LIST, false),  // FWD ext. BUTTON-LIST extension, not a real 4GL keyword
             new Keyword("currentgroup"                   ,  0, KW_BL_CURGR, false),  // FWD ext. Attr:   ButtonList:CurrentGroup
             new Keyword("currentgroup-key"               ,  0, KW_BL_CGR_K, false),  // FWD ext. Attr:   ButtonList:CurrentGroup-Key
             new Keyword("buttonfont"                     ,  0, KW_BL_BTNFN, false),  // FWD ext. Attr:   ButtonList:ButtonFont
             new Keyword("itemfont"                       ,  0, KW_BL_ITMFN, false),  // FWD ext. Attr:   ButtonList:ItemFont
             new Keyword("clear-buttonlist"               ,  9, KW_BL_GCLR , false),  // FWD ext. Method: ButtonList:Clear-ButtonList
             new Keyword("add-group"                      ,  0, KW_BL_GADD , false),  // FWD ext. Method: ButtonList:Add-Group
             new Keyword("item-fromposition"              ,  6, KW_BL_GIFP , false),  // FWD ext. Method: ButtonListGroup:Item-FromPosition
             new Keyword("add-item"                       ,  0, KW_BL_IADD , false),  // FWD ext. Method: ButtonListGroup:Add-Item
             new Keyword("get-group"                      ,  0, KW_BL_G_GR , false),  // FWD ext. Method: ButtonList:Get-Group
             new Keyword("get-group-item"                 ,  0, KW_BL_G_GRI, false),  // FWD ext. Method: ButtonListGroup:Get-Group-Item
             new Keyword("group-key"                      ,  0, KW_BL_G_KEY, false),  // FWD ext. Attr:   ButtonListGroup:Group-Key
             new Keyword("item-key"                       ,  0, KW_BL_GIKEY, false),  // FWD ext. Attr:   ButtonListGroupItem:Item-Key
             new Keyword("num-groups"                     ,  0, KW_BL_NGR  , false),  // FWD ext. Attr:   ButtonList:Num-Groups
             new Keyword("num-group-items"                ,  0, KW_BL_NGRI , false),  // FWD ext. Attr:   ButtonListGroup:Num-Group-Items
             new Keyword("buttons"                        ,  6, KW_BUTTON  , false),  // handles "separate keyword" button too
             new Keyword("by"                             ,  0, KW_BY      , true ),
             new Keyword("by-pointer"                     ,  0, KW_BY_PTR  , false),
             new Keyword("by-reference"                   ,  0, KW_BY_REF  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("by-value"                       ,  0, KW_BY_VALUE, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("by-variant-pointer"             ,  0, KW_BY_VAR_P, false),
             new Keyword("byte"                           ,  0, KW_BYTE    , false),  // missing in keyword index, found elsewhere in external program interface ref
             new Keyword("bytes-read"                     ,  0, KW_BYTES_R , false),
             new Keyword("bytes-written"                  ,  0, KW_BYTES_W , false),
             new Keyword("cache"                          ,  0, KW_CACHE   , false),
             new Keyword("cache-size"                     ,  0, KW_CACHE_SZ, false),
             new Keyword("calendar"                       ,  0, KW_CALENDAR, false), // FWD CALENDAR extension, not a real 4GL keyword
             new Keyword("calendarbackcolor"              ,  0, KW_CALBGCLR, false), // FWD CALENDAR extension
             new Keyword("calendarforecolor"              ,  0, KW_CALFGCLR, false), // FWD CALENDAR extension
             new Keyword("calendarvalue"                  ,  0, KW_CALVALUE, false), // CALENDAR:CalendarValue extension
             new Keyword("call"                           ,  0, KW_CALL    , true ),
             new Keyword("call-name"                      ,  0, KW_CALL_NAM, false),
             new Keyword("call-type"                      ,  0, KW_CALL_TYP, false),
             new Keyword("cancel-break"                   ,  0, KW_CANC_BRK, false),
             new Keyword("callback"                       ,  0, KW_CALLBACK, false),  // FWD TIMER extension
             new Keyword("cancel-button"                  ,  0, KW_CANCEL_B, false),
             new Keyword("cancel-pick"                    ,  0, KW_CANCEL_P, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("cancel-requests"                ,  0, KW_CANCEL_R, false),
             new Keyword("cancelled"                      ,  0, KW_CANCELLD, false),
             new Keyword("can-create"                     ,  0, KW_CAN_CREA, false),
             new Keyword("can-delete"                     ,  0, KW_CAN_DEL , false),
             new Keyword("can-do"                         ,  0, KW_CAN_DO  , true ),
             new Keyword("can-dump"                       ,  0, KW_CAN_DUMP, true ),
             new Keyword("can-find"                       ,  0, KW_CAN_FIND, true ),
             new Keyword("can-load"                       ,  0, KW_CAN_LOAD, true ),
             new Keyword("can-query"                      ,  0, KW_CAN_QRY , false),
             new Keyword("can-read"                       ,  0, KW_CAN_READ, false),
             new Keyword("can-set"                        ,  0, KW_CAN_SET , false),
             new Keyword("can-write"                      ,  0, KW_CAN_WRT , false),
             new Keyword("upper"                          ,  0, KW_CAPS    , false),  // missing in keyword index, found elsewhere in SQL ref
             new Keyword("caps"                           ,  0, KW_CAPS    , false),
             new Keyword("captionfont"                    ,  0, KW_CAPFNT  , false),  // FWD extension, WithCaption:CAPTIONFONT
             new Keyword("captionfont-size"               ,  0, KW_CAPFNTSZ, false),  // FWD extension, WithCaption:CAPTIONFONT-SIZE
             new Keyword("careful-paint"                  ,  0, KW_CARE_PNT, false),
             new Keyword("case"                           ,  0, KW_CASE    , true ),
             new Keyword("case-sensitive"                 ,  8, KW_CASE_SEN, true ),
             new Keyword("cast"                           ,  0, KW_CAST    , true ),
             new Keyword("catch"                          ,  0, KW_CATCH   , false),
             new Keyword("cdecl"                          ,  0, KW_CDECL   , false),
             new Keyword("cease"                          ,  0, KW_CEASE   , false),  // FWD TIMER extension
             new Keyword("centered"                       ,  6, KW_CENTER  , true ),
             new Keyword("chained"                        ,  0, KW_CHAINED , false),
             new Keyword("change-node-direct"             ,  0, KW_C_NOD_D , false),  // FWD extension, not a real 4GL keyword
             new Keyword("change-top-visible-node"        ,  0, KW_C_T_V_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("character"                      ,  4, KW_CHAR    , false),
             new Keyword("character_length"               ,  0, KW_CHAR_LEN, false),  // possible SQL keyword in the keyword index but no reference found in the SQL 89 reference
             new Keyword("charset"                        ,  0, KW_CHARSET , false),
             new Keyword("chart"                          ,  0, KW_CHART   , false),  // FWD extension, not a real 4GL keyword
             new Keyword("chart-add-picture"              ,  0, KW_RPT_CAP , false),  // FWD extension, not real 4GL; export Jasper report to csv
             new Keyword("checked"                        ,  0, KW_CHECKED , false),
             new Keyword("check"                          ,  0, KW_CHECK   , true ),
             new Keyword("check-agent-mode"               ,  0, KW_CHECK_AM, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("check-boxes"                    ,  0, KW_CHECK_BO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("child-buffer"                   ,  0, KW_CHLD_BUF, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("clear-tabs"                     ,  0, KW_CLR_TABS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("current-tab"                    ,  0, KW_CURR_TAB, false),  // FWD extension, not a real 4GL keyword
             new Keyword("choices"                        ,  0, KW_CHOICES , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("choose"                         ,  0, KW_CHOOSE  , false),
             new Keyword("chr"                            ,  0, KW_CHR     , true ),
             new Keyword("child-num"                      ,  0, KW_CHLD_NUM, false),
             new Keyword("class"                          ,  0, KW_CLASS   , false),
             new Keyword("class-type"                     ,  0, KW_CLS_TYPE, false),
             new Keyword("clipboard"                      ,  0, KW_CLIP    , true ),
             new Keyword("clear"                          ,  0, KW_CLEAR   , true ),
             new Keyword("clear-all"                      ,  0, KW_CLR_ALL , false),  // FWD extension, not a real 4GL keyword
             new Keyword("clear-appl-context"             ,  0, KW_CLR_AP_C, false),
             new Keyword("clear-attachments-list"         ,  0, KW_CLR_ATTL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("clear-bcc-list"                 ,  0, KW_CLR_BCCL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("clear-cc-list"                  ,  0, KW_CLR_CC_L, false),  // FWD extension, not a real 4GL keyword
             new Keyword("clear-embedded-image-list"      ,  0, KW_CLR_EMBL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("clear-log"                      ,  0, KW_CLR_LOG , false),
             new Keyword("clear-nodes"                    ,  0, KW_CLR_NODS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("clear-selection"                , 12, KW_CLR_SEL , false),
             new Keyword("clear-sort-arrows"              , 16, KW_CLR_S_AR, false),
             new Keyword("cleartablet"                    ,  0, KW_CLEA_TAB, false),  // FWD extension, not a real 4GL keyword
             new Keyword("clearsigwindow"                 ,  0, KW_CLEA_WIN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-connection-id"           ,  0, KW_CLNT_C_I, false),
             new Keyword("client-disconnected"            ,  0, KW_CLNT_DIS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-principal"               ,  0, KW_CLNT_PRL, false),
             new Keyword("clear-to-list"                  ,  0, KW_CLR_TO_L, false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-external-ip"             ,  0, KW_CLN_IP  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-port"                    ,  0, KW_CLN_PORT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-timezone"                ,  0, KW_CLN_TZ  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-ip-capture-time"         ,  0, KW_CLN_TIME, false),  // FWD extension, not a real 4GL keyword
             new Keyword("client-tty"                     ,  0, KW_CLNT_TTY, false),
             new Keyword("client-type"                    ,  0, KW_CLNT_TYP, false),
             new Keyword("client-workstation"             ,  0, KW_CLNT_WS , false),
             new Keyword("clob"                           ,  0, KW_CLOB    , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("clone-node"                     ,  0, KW_CLONE_ND, false),
             new Keyword("close"                          ,  0, KW_CLOSE   , false),
             new Keyword("close-log"                      ,  0, KW_CLOSE_LG, false),
             new Keyword("closeallprocs"                  ,  0, KW_CLOSE_AP, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("clear-node-image-list"          ,  0, KW_CLR_NIML, false),  // FWD extension, not a real 4GL keyword
             new Keyword("cancel-requests-after"          ,  0, KW_CNCL_R_A, false),
             new Keyword("code"                           ,  0, KW_CODE    , false),
             new Keyword("codebase-locator"               ,  0, KW_CODEBASE, true ),
             new Keyword("codepage-convert"               ,  0, KW_CP_CVT  , false),
             new Keyword("codepage"                       ,  0, KW_CP      , false),
             new Keyword("col-of"                         ,  0, KW_COL_OF  , false),
             new Keyword("collapse-all"                   ,  0, KW_COLL_ALL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("collapse-all-except"            ,  0, KW_COLL_A_E, false),  // FWD extension, not a real 4GL keyword
             new Keyword("collapse-node"                  ,  0, KW_COL_NODE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("collate"                        ,  0, KW_COLLATE , false),
             new Keyword("colon"                          ,  0, KW_COLON   , true ),
             new Keyword("colon-aligned"                  , 11, KW_COLON_AL, false),
             new Keyword("color"                          ,  0, KW_COLOR   , true ),
             new Keyword("color-table"                    ,  0, KW_COLR_TAB, false),
             new Keyword("column"                         ,  3, KW_COL     , false),
             new Keyword("column-bgcolor"                 ,  0, KW_COL_BGC , false),
             new Keyword("column-codepage"                ,  0, KW_COL_CP  , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("column-dcolor"                  ,  0, KW_COL_DC  , false),
             new Keyword("column-fgcolor"                 ,  0, KW_COL_FGC , false),
             new Keyword("column-font"                    ,  0, KW_COL_FONT, false),
             new Keyword("column-label"                   , 10, KW_COL_LAB , true ),
             new Keyword("column-movable"                 ,  0, KW_COL_MOV , false),
             new Keyword("column-of"                      ,  0, KW_COL_OF  , false),
             new Keyword("column-pfcolor"                 ,  0, KW_COL_PFC , false),
             new Keyword("column-read-only"               ,  0, KW_COL_R_O , false),
             new Keyword("column-resizable"               ,  0, KW_COL_RES , false),
             new Keyword("column-scrolling"               ,  0, KW_COL_SCR , false),
             new Keyword("column-sorting"                 ,  0, KW_COL_SRT , false),
             new Keyword("columns"                        ,  0, KW_COLUMNS , true ),
             new Keyword("command"                        ,  0, KW_COMMAND , false),
             new Keyword("com-data"                       ,  0, KW_COM_DATA, false),  // FWD extension, not a real 4GL keyword
             new Keyword("com-handle"                     ,  0, KW_COM_HNDL, false),  // missing in keyword index, found elsewhere in external program interface ref
             new Keyword("com-self"                       ,  0, KW_COM_SELF, false),
             new Keyword("compare"                        ,  0, KW_COMPARE , false),
             new Keyword("compares"                       ,  0, KW_COMPARES, false),
             new Keyword("combo-box"                      ,  0, KW_COMBO_BX, false),
             new Keyword("compile"                        ,  0, KW_COMPILE , false),
             new Keyword("compiler"                       ,  0, KW_COMPILER, true ),
             new Keyword("complete"                       ,  0, KW_COMPLETE, false),
             new Keyword("component-handle"               ,  0, KW_COM_HNDL, false),
             new Keyword("config-name"                    ,  0, KW_CFG_NAME, false),
             new Keyword("connect"                        ,  0, KW_CONN    , false),
             new Keyword("connected"                      ,  0, KW_CONN_ED , true ),
             new Keyword("connection-type"                ,  0, KW_CONNTYPE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("constructor"                    ,  0, KW_CONSTRUC, false),
             new Keyword("context"                        ,  0, KW_CTX     , false),
             new Keyword("context-help"                   ,  0, KW_CTX_H   , false),
             new Keyword("context-help-file"              ,  0, KW_CTX_H_F , false),
             new Keyword("context-help-id"                ,  0, KW_CTX_H_ID, false),
             new Keyword("context-popup"                  ,  0, KW_CTX_POP , false),
             new Keyword("contains"                       ,  0, KW_CONTAINS, false),
             new Keyword("contents"                       ,  0, KW_CONTENTS, false),
             new Keyword("context-path"                   ,  0, KW_CTX_PATH, false),  // FWD extension, not a real 4GL keyword
             new Keyword("control"                        ,  0, KW_CONTROL , true ),
             new Keyword("control-box"                    ,  0, KW_CNTRL_BX, false),
             new Keyword("control-container"              ,  0, KW_CNTRL_FR, false),  // missing in keyword index (and other API ref), found in customer code as a synonym
             new Keyword("control-frame"                  ,  0, KW_CNTRL_FR, false),
             new Keyword("control-name"                   ,  0, KW_CNTRL_NM, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("controls"                       ,  0, KW_CONTROLS, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("convert"                        ,  0, KW_CONVERT , false),
             new Keyword("convert-datetime"               ,  0, KW_CVT_DT  , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("convert-to-offset"              , 15, KW_CVT_2OFF, false),
             new Keyword("convert-3d-colors"              ,  0, KW_CVT_3D_C, false),
             new Keyword("cookie-date"                    ,  0, KW_COOKIE_D, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("copy"                           ,  0, KW_COPY    , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("copy-dataset"                   ,  0, KW_CPY_DSET, false),
             new Keyword("copy-lob"                       ,  0, KW_CPY_LOB , true ),
             new Keyword("copy-sax-attributes"            ,  0, KW_CPY_SATR, false),
             new Keyword("copy-temp-table"                ,  0, KW_CPY_TTBL, false),
             new Keyword("count"                          ,  0, KW_COUNT   , false),
             new Keyword("count-of"                       ,  0, KW_COUNT_OF, true ),
             new Keyword("coverage"                       ,  0, KW_COVERAGE, false),  // missing from keyword index, found in customer code and UNTESTED at this time
             new Keyword("cpcase"                         ,  0, KW_CPCASE  , false),
             new Keyword("cpcoll"                         ,  0, KW_CPCOLL  , false),
             new Keyword("cpinternal"                     ,  5, KW_CPINTERN, false),  // undocumented abbreviation (keyword is in the 4GL keyword index but no abbreviation is listed)
             new Keyword("cplog"                          ,  0, KW_CPLOG   , false),
             new Keyword("cpprint"                        ,  0, KW_CPPRINT , false),
             new Keyword("cprcodein"                      ,  0, KW_CPRCODEI, false),
             new Keyword("cprcodeout"                     ,  0, KW_CPRCODEO, false),
             new Keyword("cpstream"                       ,  0, KW_CPSTREAM, false),
             new Keyword("cpterm"                         ,  0, KW_CPTERM  , false),
             new Keyword("crc-value"                      ,  0, KW_CRC_VAL , false),
             new Keyword("create"                         ,  0, KW_CREATE  , true ),
             new Keyword("create-column"                  ,  0, KW_CRT_COL , false),  // FWD extension, not a real 4GL keyword
             new Keyword("create-image"                   ,  0, KW_CRE_IMAG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("create-like"                    ,  0, KW_CREAT_LK, false),
             new Keyword("create-like-sequential"         ,  0, KW_CR_LK_SQ, false),
             new Keyword("create-on-add"                  ,  0, KW_CREAT_OA, false),  // missing from keyword index, found in customer code and UNTESTED at this time
             new Keyword("create-merged-image"            ,  0, KW_CRT_MIMG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("create-node"                    ,  0, KW_CREAT_ND, false),
             new Keyword("create-node-namespace"          ,  0, KW_CREAT_NN, false),
             new Keyword("create-result-list-entry"       ,  0, KW_CREAT_RL, false),
             new Keyword("create-sub-node"                ,  0, KW_CREAT_SN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("create-test-file"               ,  0, KW_CREAT_TF, false),
             new Keyword("ctos"                           ,  0, KW_CTOS    , true ),  // undocumented
             new Keyword("currency"                       ,  0, KW_CURRENCY, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("current"                        ,  0, KW_CURRENT , true ),
             new Keyword("current-changed"                ,  0, KW_CUR_CHG , true ),
             new Keyword("current-column"                 ,  0, KW_CUR_COL , false),
             new Keyword("current-environment"            , 11, KW_CUR_ENV , false),
             new Keyword("current-iteration"              ,  0, KW_CUR_ITER, false),
             new Keyword("current-language"               , 12, KW_CUR_LANG, true ),
             new Keyword("current-result-row"             ,  0, KW_CUR_RES , false),
             new Keyword("current-request-info"           ,  0, KW_CUR_RQI , false),
             new Keyword("current-response-info"          ,  0, KW_CUR_RSI , false),
             new Keyword("current-row-modified"           ,  0, KW_CUR_R_M , false),
             new Keyword("current-window"                 ,  0, KW_CUR_WIN , true ),
             new Keyword("current-value"                  ,  0, KW_CUR_VAL , false),
             new Keyword("current-query"                  ,  0, KW_CUR_QRY,  false),
             new Keyword("current_date"                   ,  0, KW_CUR_DATE, false),  // possible SQL keyword in the keyword index but no reference found in the SQL 89 reference
             new Keyword("cursor"                         ,  4, KW_CURSOR  , true ),
             new Keyword("cursor-char"                    ,  0, KW_CUR_CHAR, false),
             new Keyword("cursor-down"                    ,  0, KW_CUR_DOWN, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("cursor-left"                    ,  0, KW_CUR_LEFT, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("cursor-line"                    ,  0, KW_CUR_LINE, false),
             new Keyword("cursor-offset"                  ,  0, KW_CUR_OFF , false),
             new Keyword("cursor-right"                   ,  0, KW_CUR_RGHT, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("cursor-up"                      ,  0, KW_CUR_UP  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("customformat"                   ,  0, KW_CALCUFMT, false),  // CALENDAR:CustomFormat extension
             new Keyword("cut"                            ,  0, KW_CUT     , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("data-bind"                      ,  0, KW_DATA_BND, false),
             new Keyword("data-entry-return"              , 14, KW_DATA_E_R, false),
             new Keyword("data-relation"                  ,  0, KW_DATA_REL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("data-source"                    ,  0, KW_DATA_SRC, true ),
             new Keyword("data-source-complete-map"       ,  0, KW_DATA_SCM, false),
             new Keyword("data-source-modified"           ,  0, KW_DATA_SM,  false),
             new Keyword("data-source-rowid"              ,  0, KW_DATA_SRI, false),
             new Keyword("data-type"                      ,  6, KW_DATATYPE, false),
             new Keyword("database"                       ,  0, KW_DATABASE, true ),
             new Keyword("dataservers"                    ,  0, KW_DATASRV , true ),
             new Keyword("dataset"                        ,  0, KW_DATASET , true ),
             new Keyword("dataset-handle"                 ,  0, KW_DSET_HND, true ),
             new Keyword("date"                           ,  0, KW_DATE    , false),
             new Keyword("datetime"                       ,  0, KW_DATETIME, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("datetime-tz"                    ,  0, KW_DATE_TZ , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("date-format"                    ,  6, KW_DATE_FMT, false),
             new Keyword("date-separator"                 ,  0, KW_DATE_SEP, false),  // FWD extension, not a real 4GL keyword
             new Keyword("day"                            ,  0, KW_DAY     , false),
             new Keyword("dbcodepage"                     ,  0, KW_DBCP    , true ),
             new Keyword("dbcollation"                    ,  0, KW_DBCOLL  , true ),
             new Keyword("dbname"                         ,  0, KW_DBNAME  , true ),
             new Keyword("dbparam"                        ,  0, KW_DBPARAM , true ),
             new Keyword("db-context"                     ,  0, KW_DB_CTXT , false),
             new Keyword("db-filter-field-mapping"        ,  0, KW_FLTR_MAP, false),  // FWD extension, not a real 4GL keyword.
             new Keyword("db-list"                        ,  0, KW_DB_LIST , false ), // missing in keyword index, found elsewhere in lang ref, tested
             new Keyword("db-references"                  ,  0, KW_DB_REF  , false),
             new Keyword("db-remote-host"                 ,  0, KW_DB_REM_H, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("db-sort-field-mapping"          ,  0, KW_SORT_MAP, false),  // FWD extension, not a real 4GL keyword.
             new Keyword("dbl-click-expanding"            ,  0, KW_DCLK_EXP, false),  // FWD extension, not a real 4GL keyword
             new Keyword("dbrestrictions"                 ,  6, KW_DBREST  , true ),
             new Keyword("dbtaskid"                       ,  0, KW_DBTASKID, true ),
             new Keyword("dbtype"                         ,  0, KW_DBTYPE  , true ),
             new Keyword("dbversion"                      ,  6, KW_DBVERS  , true ),
             new Keyword("dcolor"                         ,  0, KW_DCOLOR  , false),
             new Keyword("dde"                            ,  0, KW_DDE     , true ),
             new Keyword("dde-error"                      ,  0, KW_DDE_ERR , false),
             new Keyword("dde-id"                         ,  5, KW_DDE_ID  , false),
             new Keyword("dde-item"                       ,  0, KW_DDE_ITEM, false),
             new Keyword("dde-name"                       ,  0, KW_DDE_NAME, false),
             new Keyword("dde-notify"                     ,  0, KW_DDE_NOTI, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("dde-topic"                      ,  0, KW_DDE_TOPI, false),
             new Keyword("de-register"                    ,  0, KW_DE_REGIS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("deblank"                        ,  0, KW_DEBLANK , true ),
             new Keyword("debug"                          ,  4, KW_DEBUG   , false),
             new Keyword("debugger"                       ,  0, KW_DEBUGGER, true ),
             new Keyword("debug-alert"                    ,  0, KW_DBG_ALRT, false),
             new Keyword("debug-list"                     ,  0, KW_DBG_LST , true ),
             new Keyword("decimal"                        ,  3, KW_DEC     , false),
             new Keyword("decimal-separator"              ,  0, KW_DEC_SEP , false),  // FWD extension, not a real 4GL keyword
             new Keyword("decimals"                       ,  0, KW_DECIMALS, true ),
             new Keyword("declare"                        ,  0, KW_DECLARE , true ),
             new Keyword("declare-namespace"              ,  0, KW_DECL_NSP, false),
             new Keyword("decrypt"                        ,  0, KW_DECRYPT , false),
             new Keyword("default"                        ,  0, KW_DEFAULT , true ),
             new Keyword("default-action"                 ,  0, KW_DEF_ACTN, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("default-buffer-handle"          ,  0, KW_DEF_BUFH, false),
             new Keyword("default-button"                 ,  9, KW_DEFLT_BN, false),
             new Keyword("default-commit"                 ,  0, KW_DEF_COMM, false),
             new Keyword("default-extension"              , 10, KW_DEF_EXTN, false),
             new Keyword("default-noxlate"                , 12, KW_DEF_NOXL, true ),
             new Keyword("default-pop-up"                 ,  0, KW_DEF_POP , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("default-string"                 ,  0, KW_DEF_STR , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("default-value"                  ,  0, KW_DEF_VAL , false),
             new Keyword("default-window"                 ,  0, KW_DEF_WIN , true ),
             new Keyword("define"                         ,  3, KW_DEFINE  , true ),
             new Keyword("define-user-event-manager"      ,  0, KW_DEF_UEVM, false),
             new Keyword("delegate"                       ,  0, KW_DELEGATE, false),
             new Keyword("delete"                         ,  0, KW_DELETE  , true ),
             new Keyword("delete-character"               , 11, KW_DEL_CHAR, false),
             new Keyword("delete-column"                  ,  0, KW_DEL_COL , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("deletecookie"                   ,  0, KW_DEL_COOK, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("delete-cookie"                  ,  0, KW_DEL_COOK, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("delete-current-row"             ,  0, KW_DEL_C_R , false),
             new Keyword("delete-end-line"                ,  0, KW_DEL_E_L , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("delete-field"                   ,  0, KW_DEL_FLD , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("delete-header-entry"            ,  0, KW_DEL_H_EN, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("delete-line"                    ,  0, KW_DEL_LINE, false),
             new Keyword("delete-node"                    ,  0, KW_DEL_NODE, false),
             new Keyword("delete-result-list-entry"       ,  0, KW_DEL_R_L , false),
             new Keyword("delete-selected-row"            ,  0, KW_DEL_S_R , false),
             new Keyword("delete-selected-rows"           ,  0, KW_DEL_S_RS, false),
             new Keyword("delete-source"                  ,  0, KW_DEL_S_C , false),  // FWD extension
             new Keyword("delete-word"                    ,  0, KW_DEL_WORD, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("descending"                     ,  4, KW_DESCEND , true ),  // handles "separate keyword" desc too
             new Keyword("description"                    ,  0, KW_DESCR   , false),  // missing in keyword index, found in customer code
             new Keyword("deselect-focused-row"           ,  0, KW_DESEL_FR, false),
             new Keyword("deselect-rows"                  ,  0, KW_DESEL_R , false),
             new Keyword("deselect-selected-row"          ,  0, KW_DESEL_SR, false),
             new Keyword("deselection"                    ,  0, KW_DESELCTN, false),
             new Keyword("destructor"                     ,  0, KW_DESTRUCT, false),
             new Keyword("detach-data-source"             ,  0, KW_DET_DSRC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("device-id"                      ,  0, KW_DEVICEID, false),  // FWD extension, not a real 4GL keyword
             new Keyword("dialog-box"                     ,  0, KW_DIALOG  , false),
             new Keyword("dictionary"                     ,  4, KW_DICT    , true ),
             new Keyword("dir"                            ,  0, KW_DIR     , false),
             new Keyword("directory"                      ,  0, KW_DIRECTRY, false),  // missing in keyword index, found in customer code
             new Keyword("delimiter"                      ,  0, KW_DELIMIT , true ),
             new Keyword("disable"                        ,  0, KW_DISABLE , true ),
             new Keyword("disable-auto-zap"               ,  0, KW_DIS_A_ZA, true ),
             new Keyword("disable-cfg-edit"               ,  0, KW_DIS_CEDT, false), // FWD extension, not a real 4GL keyword.
             new Keyword("disable-connections"            ,  0, KW_DISABL_C, false),
             new Keyword("disable-dump-triggers"          ,  0, KW_DIS_D_TR, false),
             new Keyword("disable-load-triggers"          ,  0, KW_DIS_L_TR, false),
             new Keyword("disable-redraw"                 ,  0, KW_DIS_REDR, false), // FWD extension, not real 4GL!
             new Keyword("disable-row-striping"           ,  0, KW_DIS_STRP, false), // FWD extension, not a real 4GL keyword.
             new Keyword("disabled"                       ,  0, KW_DISABLED, false),
             new Keyword("disconnect"                     ,  6, KW_DISCONN , true ),
             new Keyword("dispatch"                       ,  0, KW_DISPATCH, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("display"                        ,  4, KW_DISP    , true ),
             new Keyword("display-message"                ,  0, KW_DISP_MSG, false),
             new Keyword("display-timezone"               ,  0, KW_DISP_TZ , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("display-type"                   ,  9, KW_DISP_TYP, false),
             new Keyword("distinct"                       ,  0, KW_DISTINCT, true ),
             new Keyword("dll-call-type"                  ,  0, KW_DLL_C_T,  true ),
             new Keyword("do"                             ,  0, KW_DO      , true ),
             new Keyword("domain-description"             ,  0, KW_DOMAIN_D, false),
             new Keyword("domain-name"                    ,  0, KW_DOMAIN_N, false),
             new Keyword("domain-type"                    ,  0, KW_DOMAIN_T, false),
             new Keyword("dos"                            ,  0, KW_DOS     , true ),
             new Keyword("double"                         ,  0, KW_DOUBLE  , false),
             new Keyword("down"                           ,  0, KW_DOWN    , true ),
             new Keyword("drag-drop"                      ,  0, KW_DRAGDROP, false),  // FWD extension, not a real 4GL keyword
             new Keyword("drag-drop-other-tree"           ,  0, KW_DD_OTREE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("drag-enabled"                   ,  0, KW_DRAG_EN , false),
             new Keyword("drop"                           ,  0, KW_DROP    , true ),
             new Keyword("drop-down"                      ,  0, KW_DROP_DWN, false),
             new Keyword("drop-down-list"                 ,  0, KW_DROP_LST, false),
             new Keyword("drop-file-notify"               ,  0, KW_DROP_FN , false),
             new Keyword("drop-target"                    ,  0, KW_DROP_TAR, false),
             new Keyword("dslog-manager"                  ,  0, KW_DSL_MGR , false),
             new Keyword("dump"                           ,  0, KW_DUMP    , false),
             new Keyword("dump-logging-now"               ,  0, KW_DUMP_LGN, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("dynamic-cast"                   ,  0, KW_DYN_CAST, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("dynamic-current-value"          ,  0, KW_DYN_CURV, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("dynamic-enum"                   ,  0, KW_DYN_ENUM, true ),
             new Keyword("dynamic-function"               , 12, KW_DYN_FUNC, true ),  // undocumented abbreviation found in customer code
             new Keyword("dynamic-invoke"                 ,  0, KW_DYN_INVK, true ),  // missing from keyword index, tested
             new Keyword("dynamic-new"                    ,  0, KW_DYN_NEW , true),   // missing from keyword index, tested
             new Keyword("dynamic-next-value"             ,  0, KW_DYN_NEXV, false),  // missing from keyword index, tested
             new Keyword("dynamic-property"               ,  0, KW_DYN_PROP, true),   // missing from keyword index, tested
             new Keyword("dynamic"                        ,  0, KW_DYNAMIC , false),
             new Keyword("each"                           ,  0, KW_EACH    , true ),
             new Keyword("echo"                           ,  0, KW_ECHO    , false),
             new Keyword("edge-chars"                     ,  4, KW_EDGE_C  , false),
             new Keyword("edge-pixels"                    ,  6, KW_EDGE_P  , false),
             new Keyword("edit-can-paste"                 ,  0, KW_EDIT_C_P, false),
             new Keyword("edit-can-undo"                  ,  0, KW_EDIT_C_U, false),
             new Keyword("edit-clear"                     ,  0, KW_EDIT_CLR, false),
             new Keyword("edit-copy"                      ,  0, KW_EDIT_CPY, false),
             new Keyword("edit-cut"                       ,  0, KW_EDIT_CUT, false),
             new Keyword("edit-paste"                     ,  0, KW_EDIT_PAS, false),
             new Keyword("edit-undo"                      ,  0, KW_EDIT_UND, false),
             new Keyword("editing"                        ,  0, KW_EDITING , true ),
             new Keyword("editor"                         ,  0, KW_EDITOR  , false),
             new Keyword("editor-backtab"                 ,  0, KW_EDIT_B_T, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("editor-tab"                     ,  0, KW_EDIT_TAB, false),  // missing in keyword index, found elsewhere in prog handbook
             new Keyword("else"                           ,  0, KW_ELSE    , true ),
             new Keyword("embed-image-by-file"            ,  0, KW_EMB_FILE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("embed-image-by-url"             ,  0, KW_EMB_URL , false),  // FWD extension, not a real 4GL keyword
             new Keyword("not-embedded"                   ,  0, KW_NO_EMBED, false),  // FWD extension
             new Keyword("empty"                          ,  0, KW_EMPTY   , false),
             new Keyword("empty-dataset"                  ,  0, KW_EMPTY_DS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("empty-selection"                ,  0, KW_EMPTY_SN, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("empty-temp-table"               ,  0, KW_EMPTY_TT, false),
             new Keyword("enable"                         ,  0, KW_ENABLE  , true ),
             new Keyword("enabled"                        ,  0, KW_ENABLED , false),  // FWD TIMER extension and PROFILER attribute
             new Keyword("enable-connections"             ,  0, KW_ENABLE_C, false),
             new Keyword("enable-events"                  ,  0, KW_ENABLE_E, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("encode"                         ,  0, KW_ENCODE  , true ),
             new Keyword("encoding"                       ,  0, KW_ENCODING, false),
             new Keyword("encrypt"                        ,  0, KW_ENCRYPT , false),
             new Keyword("encrypt-audit-mac-key"          ,  0, KW_ENC_AMK , false),
             new Keyword("encryption-salt"                ,  0, KW_ENC_SALT, false),
             new Keyword("end-box-selection"              ,  0, KW_END_B_SN, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("end-document"                   ,  0, KW_END_DOC , false),
             new Keyword("end-element"                    ,  0, KW_END_ELEM, false),
             new Keyword("end-event-group"                ,  0, KW_END_EV_G, false),
             new Keyword("end-search"                     ,  0, KW_END_SEAR, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("end-user-prompt"                ,  0, KW_END_USER, false),
             new Keyword("end"                            ,  0, KW_END     , true ),
             new Keyword("end-error"                      ,  0, KW_END_ERR , false),
             new Keyword("end-file-drop"                  ,  0, KW_END_F_D , false),
             new Keyword("endkey"                         ,  0, KW_ENDKEY  , false),
             new Keyword("end-key"                        ,  0, KW_ENDKEY  , false),
             new Keyword("end-move"                       ,  0, KW_END_MOV , false),
             new Keyword("end-resize"                     ,  0, KW_END_RESZ, false),
             new Keyword("end-row-resize"                 ,  0, KW_END_RRES, false),
             new Keyword("enhanced-filtering"             ,  0, KW_EH_FL,    false),  // FWD extension, not a real 4GL keyword
             new Keyword("enhanced-sorting"               ,  0, KW_EH_SR,    false),  // FWD extension, not a real 4GL keyword
             new Keyword("ensure-node-visible"            ,  0, KW_ENS_N_V , false),  // FWD extension, not a real 4GL keyword
             new Keyword("entered"                        ,  0, KW_ENTERED , false),
             new Keyword("enter-menubar"                  ,  0, KW_ENTER_MB, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("entity-expansion-limit"         ,  0, KW_ENT_EX_L, false),
             new Keyword("entry"                          ,  0, KW_ENTRY   , true ),
             new Keyword("entry-types-list"               ,  0, KW_ENT_TLST, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("enum"                           ,  0, KW_ENUM    , false ),
             new Keyword("error"                          ,  0, KW_ERROR   , false),
             new Keyword("error-code"                     ,  0, KW_ERR_CODE, false),  // missing in keyword index, found elsewhere in external program interface ref
             new Keyword("error-column"                   ,  9, KW_ERR_COL , false),
             new Keyword("error-object-detail"            ,  0, KW_ERR_OBJD, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("error-row"                      ,  0, KW_ERR_ROW,  false),
             new Keyword("error-stack-trace"              ,  0, KW_ERR_S_T ,  false),
             new Keyword("error-status"                   , 10, KW_ERR_STAT, true ),
             new Keyword("error-string"                   ,  0, KW_ERR_STR,  false),  // missing from keyword index and UNTESTED at this time
             new Keyword("eq"                             ,  0, KW_EQ      , false),
             new Keyword("escape"                         ,  0, KW_ESCAPE  , true ),
             new Keyword("etime"                          ,  0, KW_ETIME   , true ),
             new Keyword("events"                         ,  5, KW_EVENTS  , false),
             new Keyword("events-active"                  ,  0, KW_EVT_ACTI, false),  // FWD extension, not a real 4GL keyword
             new Keyword("event-group-id"                 ,  0, KW_EVT_GRID, false),
             new Keyword("event-procedure"                ,  0, KW_EVT_PROC, true ),
             new Keyword("event-procedure-context"        ,  0, KW_E_PROC_C, false),
             new Keyword("event-type"                     ,  7, KW_EVT_TYPE, false),
             new Keyword("except"                         ,  0, KW_EXCEPT  , true ),
             new Keyword("exclusive-id"                   ,  0, KW_EXCL_ID , false),
             new Keyword("exclusive-lock"                 ,  9, KW_EXC_LOCK, true ),
             new Keyword("exclusive-web-user"             ,  0, KW_EXCL_WEB, false),
             new Keyword("execute"                        ,  0, KW_EXECUTE , false),
             new Keyword("execution-log"                  ,  0, KW_EXEC_LOG, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("exists"                         ,  0, KW_EXISTS  , true ),
             new Keyword("exit"                           ,  0, KW_EXIT    , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("exit-code"                      ,  0, KW_EXITCODE, false),  // added in 11.7.3 as attribute to SESSION
             new Keyword("exp"                            ,  0, KW_EXP     , false),
             new Keyword("expand"                         ,  0, KW_EXPAND  , false),
             new Keyword("expand-all"                     ,  0, KW_EXPA_ALL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("expand-node"                    ,  0, KW_EXP_NODE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("expand-node-icon"               ,  0, KW_EXP_N_IC, false),  // FWD extension, not a real 4GL keyword
             new Keyword("expand-on-enter"                ,  0, KW_EXP_ON_E, false),  // FWD extension, not a real 4GL keyword
             new Keyword("expand-on-single-click"         ,  0, KW_EXP_SCLK, false),  // FWD extension, not a real 4GL keyword
             new Keyword("expandable"                     ,  0, KW_EXPANDBL, false),
             new Keyword("explicit"                       ,  0, KW_EXPLICIT, false),
             new Keyword("export"                         ,  0, KW_EXPORT  , true ),
             new Keyword("export-principal"               ,  0, KW_EXPORT_P, false),
             new Keyword("export-report-csv"              ,  0, KW_RPT_CSV , false),  // FWD extension, not real 4GL; export Jasper report to csv
             new Keyword("export-report-docx"             ,  0, KW_RPT_DOCX, false),  // FWD extension, not real 4GL; export Jasper report to xlsx
             new Keyword("export-report-html"             ,  0, KW_RPT_HTML, false),  // FWD extension, not real 4GL; export Jasper report to html
             new Keyword("import-csv-data"                ,  0, KW_RPT_ICSV, false),  // FWD extension, not real 4GL; export Jasper report to csv
             new Keyword("export-report-pdf"              ,  0, KW_RPT_PDF , false),  // FWD extension, not real 4GL; export Jasper report to pdf
             new Keyword("export-report-rtf"              ,  0, KW_RPT_RTF , false),  // FWD extension, not real 4GL; export Jasper report to xls
             new Keyword("export-report-xls"              ,  0, KW_RPT_XLS , false),  // FWD extension, not real 4GL; export Jasper report to xls
             new Keyword("export-report-xlsx"             ,  0, KW_RPT_XLSX, false),  // FWD extension, not real 4GL; export Jasper report to xlsx
             new Keyword("extended"                       ,  0, KW_EXTENDED, false),
             new Keyword("extent"                         ,  0, KW_EXTENT  , false),
             new Keyword("external"                       ,  0, KW_EXTERN  , false),
             new Keyword("false"                          ,  0, BOOL_FALSE , true ),
             new Keyword("fetch"                          ,  0, KW_FETCH   , true ),
             new Keyword("fetch-selected-row"             ,  0, KW_FETCH_SR, false),
             new Keyword("fields"                         ,  5, KW_FIELD   , true ),  // handles "separate keyword" field too
             new Keyword("file"                           ,  0, KW_FILE    , false),
             new Keyword("file-create-date"               ,  0, KW_FIL_C_D , false),
             new Keyword("file-create-time"               ,  0, KW_FIL_C_T , false),
             new Keyword("file-information"               ,  9, KW_FIL_INFO, true ),
             new Keyword("file-mod-date"                  ,  0, KW_FIL_M_D , false),
             new Keyword("file-mod-time"                  ,  0, KW_FIL_M_T , false),
             new Keyword("file-name"                      ,  0, KW_FIL_NAME, false),
             new Keyword("file-offset"                    ,  8, KW_FIL_OFF,  false),
             new Keyword("file-size"                      ,  0, KW_FIL_SIZE, false),
             new Keyword("file-type"                      ,  0, KW_FIL_TYPE, false),
             new Keyword("filename"                       ,  0, KW_FIL_NAME, false),
             new Keyword("fill"                           ,  0, KW_FILL    , true ),
             new Keyword("fill-in"                        ,  0, KW_FILL_IN , false),
             new Keyword("fill-mode"                      ,  0, KW_FILL_MOD, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("fill-where-string"              ,  0, KW_FILL_WST, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("filled"                         ,  0, KW_FILLED  , false),
             new Keyword("filters"                        ,  0, KW_FILTERS , false),
             new Keyword("final"                          ,  0, KW_FINAL   , false),
             new Keyword("finally"                        ,  0, KW_FINALLY , false),
             new Keyword("find"                           ,  0, KW_FIND    , true ),
             new Keyword("find-by-rowid"                  ,  0, KW_FIND_BR , false),
             new Keyword("find-case-sensitive"            ,  0, KW_FIND_CS , true ),
             new Keyword("find-current"                   ,  0, KW_FIND_CUR, false),
             new Keyword("find-failed"                    ,  0, KW_FIND_FD , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("find-first"                     ,  0, KW_FIND_1ST, false),
             new Keyword("find-global"                    ,  0, KW_FIND_GLO, true ),
             new Keyword("find-last"                      ,  0, KW_FIND_LST, false),
             new Keyword("find-next"                      ,  0, KW_FIND_NXT, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("find-next-occurrence"           ,  0, KW_FIND_NO , true ),
             new Keyword("find-node"                      ,  0, KW_FIND_NOD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("find-previous"                  ,  0, KW_FIND_PRV, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("find-prev-occurrence"           ,  0, KW_FIND_PO , true ),
             new Keyword("find-select"                    ,  0, KW_FIND_SEL, true ),
             new Keyword("find-unique"                    ,  0, KW_FIND_UNI, false),
             new Keyword("find-wrap-around"               ,  0, KW_FIND_WA , true ),
             new Keyword("finder"                         ,  0, KW_FINDER  , false),
             new Keyword("first"                          ,  0, KW_FIRST   , true ),
             new Keyword("first-async-request"            ,  0, KW_FIRST_AR, false),
             new Keyword("first-buffer"                   ,  0, KW_FIRST_BU, false),
             new Keyword("first-child"                    ,  0, KW_FIRST_CH, false),
             new Keyword("first-column"                   ,  0, KW_FIRST_CO, false),
             new Keyword("first-data-source"              ,  0, KW_FIRST_DS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("first-dataset"                  ,  0, KW_FIR_DSET, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("first-form"                     ,  0, KW_FIRST_FM, false),
             new Keyword("first-node"                     ,  0, KW_FIRST_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("first-of"                       ,  0, KW_FIRST_OF, true ),
             new Keyword("first-object"                   ,  0, KW_FIRST_OB, false),
             new Keyword("first-procedure"                , 10, KW_FIRST_PR, false),
             new Keyword("first-query"                    ,  0, KW_FIRST_QR, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("first-server"                   ,  0, KW_FIRST_SR, false),
             new Keyword("first-server-socket"            ,  0, KW_FIRST_SS, false),
             new Keyword("first-socket"                   ,  0, KW_FIRST_SO, false),
             new Keyword("first-tab-item"                 , 11, KW_FIRST_TI, false),
             new Keyword("first-visible-node"             ,  0, KW_FV_NODE,  false),  // FWD extension, not a real 4GL keyword
             new Keyword("fit-last-column"                ,  0, KW_FIT_LCOL, false),
             new Keyword("fix-codepage"                   ,  0, KW_FIX_CP  , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("fix-columns-left"               ,  0, KW_FIX_C_L , false),  // FWD extension, not a real 4GL keyword
             new Keyword("fixed-only"                     ,  0, KW_FIXD_ONL, false),
             new Keyword("fgcolor"                        ,  3, KW_FGCOLOR , false),
             new Keyword("fgcolor-rgb"                    ,  0, KW_FGCOLRGB, false),  // FWD extension, not real 4GL!
             new Keyword("flags"                          ,  0, KW_FLAGS   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("flat-button"                    ,  0, KW_FLAT_BUT, false),
             new Keyword("float"                          ,  0, KW_FLOAT   , false),
             new Keyword("focus"                          ,  0, KW_FOCUS   , true ),
             new Keyword("focus-and-select"               ,  0, KW_FOC_ASEL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("focused-and-selected-node"      ,  0, KW_FS_NODE , false),  // FWD extension, not a real 4GL keyword
             new Keyword("focused-and-selected-node-key"  ,  0, KW_FS_NKEY , false),  // FWD extension, not a real 4GL keyword
             new Keyword("focused-node-key"               ,  0, KW_FOC_NKEY, false),  // FWD extension, not a real 4GL keyword
             new Keyword("focused-node"                   ,  0, KW_FOC_NODE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("focused-row"                    ,  0, KW_FOCUS_R , false),
             new Keyword("focused-row-selected"           ,  0, KW_FOCUS_RS, false),
             new Keyword("font"                           ,  0, KW_FONT    , true ),
             new Keyword("font-bold"                      ,  0, KW_FNT_BOLD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("font-italic"                    ,  0, KW_FNT_ITAL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("font-name"                      ,  0, KW_FNT_NAME, false),  // FWD extension, not a real 4GL keyword
             new Keyword("font-size"                      ,  0, KW_FNT_SIZE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("font-table"                     ,  0, KW_FONT_TAB, false),
             new Keyword("font-underline"                 ,  0, KW_FNT_UNDL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("for"                            ,  0, KW_FOR     , true ),
             new Keyword("force-database-join"            ,  0, KW_DB_JOIN , false),
             new Keyword("force-file"                     ,  0, KW_FORCE_F , false),
             new Keyword("foreground"                     ,  4, KW_FORE    , false),
             new Keyword("foreign-key-hidden"             ,  0, KW_F_KEY_H , false),
             new Keyword("form-input"                     ,  0, KW_FORM_INP, false),
             new Keyword("form-long-input"                ,  0, KW_FORM_LIN, false),
             new Keyword("format"                         ,  4, KW_FORMAT  , true ),  // handles "separate keyword" form too
             new Keyword("format-datetime"                ,  0, KW_FMT_DT  , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("formatstyle"                    ,  0, KW_CALFMTST, false),  // FWD extension for CALENDAR:FormatStyle, not a real 4GL keyword
             new Keyword("formatted"                      ,  8, KW_FORMATTE, false),
             new Keyword("forward-only"                   ,  0, KW_FWD_ONLY, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("forwards"                       ,  7, KW_FORWARD , false),  // handles "separate keyword" forward too
             new Keyword("fragment"                       ,  7, KW_FRAGMENT, false),
             new Keyword("frame"                          ,  4, KW_FRAME   , true ),
             new Keyword("frame-col"                      ,  0, KW_FR_COL  , true ),
             new Keyword("frame-db"                       ,  0, KW_FR_DB   , true ),
             new Keyword("frame-down"                     ,  0, KW_FR_DOWN , true ),
             new Keyword("frame-field"                    ,  0, KW_FR_FIELD, true ),
             new Keyword("frame-file"                     ,  0, KW_FR_FILE , true ),
             new Keyword("frame-index"                    , 10, KW_FR_INDEX, true ),
             new Keyword("frame-line"                     ,  0, KW_FR_LINE , true ),
             new Keyword("frame-name"                     ,  0, KW_FR_NAME , true ),
             new Keyword("frame-row"                      ,  0, KW_FR_ROW  , true ),
             new Keyword("frame-spacing"                  ,  9, KW_FR_SPACE, false),
             new Keyword("frame-value"                    ,  9, KW_FR_VAL  , true ),
             new Keyword("frame-x"                        ,  0, KW_FR_X    , false),
             new Keyword("frame-y"                        ,  0, KW_FR_Y    , false),
             new Keyword("from"                           ,  0, KW_FROM    , true ),
             new Keyword("from-current"                   ,  8, KW_FROM_CUR, false),
             new Keyword("from-chars"                     ,  6, KW_FROM_CHR, true ),
             new Keyword("from-pixels"                    ,  6, KW_FROM_PIX, true ),
             new Keyword("frequency"                      ,  0, KW_FREQ    , false),
             new Keyword("full-height-chars"              , 11, KW_FULL_H_C, false),
             new Keyword("full-height-pixels"             , 13, KW_FULL_H_P, false),
             new Keyword("full-width-chars"               , 10, KW_FULL_W_C, false),
             new Keyword("full-width-pixels"              , 12, KW_FULL_W_P, false),
             new Keyword("full-pathname"                  , 10, KW_FULLPATH, false),
             new Keyword("function"                       ,  0, KW_FUNCT   , false),
             new Keyword("function-call-type"             ,  0, KW_FUNC_C_T, true ),
             new Keyword("fwd-logfile"                    ,  0, KW_FWD_LOGF, false),  // FWD extension, not real 4GL!
             new Keyword("fwd-client-driver"              ,  0, KW_FWD_DRIV, false),  // FWD extension, not real 4GL!
             new Keyword("gateways"                       ,  7, KW_GW      , true ),
             new Keyword("ge"                             ,  0, KW_GTE     , false),
             new Keyword("generate-md5"                   ,  0, KW_GEN_MD5 , false),
             new Keyword("generate-pbe-key"               ,  0, KW_GEN_PBEK, false),
             new Keyword("generate-pbe-salt"              ,  0, KW_GEN_PBES, false),
             new Keyword("generate-random-key"            ,  0, KW_GEN_RNDK, false),
             new Keyword("generate-uuid"                  ,  0, KW_GEN_UUID, false),
             new Keyword("get"                            ,  0, KW_GET     , false),
             new Keyword("get-attachments-list"           ,  0, KW_GET_ATTL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-attr-call-type"             ,  0, KW_GET_A_CT, true ),
             new Keyword("getattribute"                   ,  0, KW_GETATTRI, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-attribute"                  ,  0, KW_GET_ATTR, false),
             new Keyword("get-attribute-node"             ,  0, KW_GET_A_N , false),
             new Keyword("get-bcc-list"                   ,  0, KW_GET_BCCL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-binary-data"                ,  0, KW_GET_BDAT, false),
             new Keyword("get-bits"                       ,  0, KW_GET_BITS, false),
             new Keyword("get-blue-value"                 ,  8, KW_GET_BLUE, false),
             new Keyword("get-browse-column"              , 13, KW_GET_BR_C, false),  // undocumented abbreviation (missing from keyword index) usage found in customer code
             new Keyword("get-buffer-handle"              ,  0, KW_GET_BUFH, true ),
             new Keyword("getbyte"                        ,  0, KW_GET_BYTE, true ),
             new Keyword("get-byte"                       ,  0, KW_GET_BYTE, true ),
             new Keyword("get-byte-order"                 ,  0, KW_GET_B_OR, false),
             new Keyword("get-bytes"                      ,  0, KW_GET_BYTS, false),
             new Keyword("get-bytes-available"            ,  0, KW_GET_B_A , false),
             new Keyword("get-callback-proc-context"      ,  0, KW_GET_CBPC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-callback-proc-name"         ,  0, KW_GET_CBPN, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-cc-list"                    ,  0, KW_GET_CC_L, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-cell-bgcolor"               ,  0, KW_G_C_BGCO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-cell-fgcolor"               ,  0, KW_G_C_FGCO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-cell-string"                ,  0, KW_GET_C_S , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-class"                      ,  0, KW_GETCLASS, false),  // missing from keywords, used by a customer
             new Keyword("get-column-position"            ,  0, KW_G_COL_P , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-column-width"               ,  0, KW_G_COL_W , false),  // FWD extension, not a real 4GL keyword
             new Keyword("getcgi"                         ,  0, KW_GET_CGI , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-cgi"                        ,  0, KW_GET_CGI , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-cgi-list"                   ,  0, KW_GET_CGIL, false),
             new Keyword("get-cgi-long"                   ,  0, KW_GET_CGL , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-cgi-long-value"             ,  0, KW_GET_CGLV, false),
             new Keyword("get-cgi-value"                  ,  0, KW_GET_CGIV, false),
             new Keyword("get-changes"                    ,  0, KW_GET_CHG , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-child"                      ,  0, KW_GET_CHLD, false),
             new Keyword("get-child-relation"             , 13, KW_GET_CREL, false),  // missing from keyword index, manually tested abbrev and reserved status
             new Keyword("get-client"                     ,  0, KW_GET_CLNT, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-codepages"                  , 12, KW_GET_CODP, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-collation"                  ,  0, KW_GET_CLL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-collations"                 ,  0, KW_GET_COLL, true ),
             new Keyword("getcookie"                      ,  0, KW_GET_COOK, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-cookie"                     ,  0, KW_GET_COOK, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-config"                     ,  0, KW_GET_CFG , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-config-value"               ,  0, KW_GET_CFGV, false),
             new Keyword("get-current"                    ,  0, KW_GET_CUR , false),
             new Keyword("get-dataset-buffer"             ,  0, KW_GET_DS_B, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-db-client"                  ,  0, KW_GET_DBCL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-dir"                        ,  0, KW_GET_DIR , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-document-element"           ,  0, KW_GET_D_E , false),
             new Keyword("get-double"                     ,  0, KW_GET_DBL , false),
             new Keyword("get-dropped-file"               ,  0, KW_GET_D_F , false),
             new Keyword("get-dynamic"                    ,  0, KW_GET_DYN , false),
             new Keyword("get-embedded-image-list"        ,  0, KW_GET_EMBL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-error-column"               ,  0, KW_GET_ERRC, true ),
             new Keyword("get-error-row"                  ,  0, KW_GET_ERRR, true ),
             new Keyword("getfield"                       ,  0, KW_GET_FLD , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-field"                      ,  0, KW_GET_FLD , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-file"                       ,  0, KW_GET_FILE, false),
             new Keyword("get-file-name"                  ,  0, KW_GET_FNAM, true ),
             new Keyword("get-file-offset"                , 14, KW_GET_FOFF, true ),
             new Keyword("get-first"                      ,  0, KW_GET_1ST , false),
             new Keyword("get-first-child-node"           ,  0, KW_GET_FCN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-float"                      ,  0, KW_GET_FLT , false),
             new Keyword("get-green-value"                ,  9, KW_GET_GRN , false),
             new Keyword("get-header-entry"               ,  0, KW_GET_HD_E, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-index-by-namespace-name"    ,  0, KW_GET_IBNN, false),
             new Keyword("get-index-by-qname"             ,  0, KW_GET_IBQN, false),
             new Keyword("get-int64"                      ,  0, KW_GET_I64 , false),
             new Keyword("get-iteration"                  ,  0, KW_GET_ITER, false),
             new Keyword("get-key-value"                  , 11, KW_GET_K_V , true ),
             new Keyword("get-last"                       ,  0, KW_GET_LAST, false),
             new Keyword("get-license"                    ,  0, KW_GET_LIC , false),  // missing in keyword index, found in Possenet code as undocumented built-in function
             new Keyword("get-localname-by-index"         ,  0, KW_GET_LNBI, false),
             new Keyword("get-login-parameter"            ,  0, KW_GET_LPRM, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-long"                       ,  0, KW_GET_LONG, false),
             new Keyword("get-long-value"                 ,  0, KW_GET_L_V , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-mouse-position"             ,  0, KW_GET_MOP,  false),  // FWD extension, not a real 4GL
             new Keyword("get-message"                    ,  0, KW_GET_MSG , false),
             new Keyword("get-message-groups"             ,  0, KW_GET_MSGG, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-messages"                   ,  0, KW_GET_MSGS, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-next"                       ,  0, KW_GET_NEXT, false),
             new Keyword("get-next-node"                  ,  0, KW_GET_N_N , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-next-sibling-node"          ,  0, KW_GET_NSN , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node"                       ,  0, KW_GET_NODE, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-node-at"                    ,  0, KW_GET_N_AT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node-bgcolor"               ,  0, KW_GET_N_BG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node-fgcolor"               ,  0, KW_GET_N_FG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node-has-children"          ,  0, KW_GET_N_HC, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node-level"                 ,  0, KW_GET_NLEV, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node-text"                  ,  0, KW_GET_NTXT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-node-visible-in-viewport"   ,  0, KW_GET_NVV , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-number"                     ,  0, KW_GET_NUM , false),
             new Keyword("get-parent"                     ,  0, KW_GET_PAR , false),
             new Keyword("get-parent-node"                ,  0, KW_GET_PARN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-pointer-value"              ,  0, KW_GET_PTR , false),
             new Keyword("get-prev"                       ,  0, KW_GET_PREV, false),
             new Keyword("get-prev-sibling-node"          ,  0, KW_GET_PSN , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-printers"                   ,  0, KW_GET_PRT , false),
             new Keyword("get-property"                   ,  0, KW_GET_PROP, false),
             new Keyword("get-qname-by-index"             ,  0, KW_GET_QNBI, false),
             new Keyword("get-red-value"                  ,  7, KW_GET_RED , false),
             new Keyword("get-relation"                   ,  0, KW_GET_REL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-repositioned-row"           ,  0, KW_GET_R_R , false),
             new Keyword("get-rgb-value"                  ,  0, KW_GET_RGB , false),
             new Keyword("get-sheet-range-columns"        ,  0, KW_RPT_GSRC, false),  // FWD extension, not real 4GL; export Jasper report to csv
             new Keyword("get-sheet-range-rows"           ,  0, KW_RPT_GSRR, false),  // FWD extension, not real 4GL; export Jasper report to csv
             new Keyword("get-short"                      ,  0, KW_GET_SHRT, false),
             new Keyword("get-selected-node-colors"       ,  0, KW_GET_SNC , false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-selected-widget"            , 12, KW_GET_SELW, false),
             new Keyword("get-serialized"                 ,  0, KW_GET_SER , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-signature"                  ,  0, KW_GET_SIG , false),
             new Keyword("get-size"                       ,  0, KW_GET_SZ  , false),
             new Keyword("get-socket-option"              ,  0, KW_GET_S_O , false),
             new Keyword("get-source-buffer"              ,  0, KW_GET_SRCB, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-string"                     ,  0, KW_GET_STR , false),
             new Keyword("get-tab-item"                   ,  0, KW_GET_TI  , false),
             new Keyword("get-text-height-chars"          , 15, KW_GET_THCH, false),
             new Keyword("get-text-height-pixels"         , 17, KW_GET_THPX, false),
             new Keyword("get-text-width-chars"           , 14, KW_GET_TWCH, false),
             new Keyword("get-text-width-pixels"          , 16, KW_GET_TWPX, false),
             new Keyword("get-tree-node"                  ,  0, KW_GET_TNOD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-to-list"                    ,  0, KW_GET_TO_L, false),  // FWD extension, not a real 4GL keyword
             new Keyword("get-top-buffer"                 ,  0, KW_GET_TOPB, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("get-transaction-state"          ,  0, KW_GET_T_S , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-type-by-index"              ,  0, KW_GET_TBI , false),
             new Keyword("get-type-by-namespace-name"     ,  0, KW_GET_TBNN, false),
             new Keyword("get-type-by-qname"              ,  0, KW_GET_TBQN, false),
             new Keyword("get-unsigned-short"             ,  0, KW_GET_USHT, false),
             new Keyword("get-unsigned-long"              ,  0, KW_GET_UL  , false),
             new Keyword("get-uri-by-index"               ,  0, KW_GET_UBI , false),
             new Keyword("get-user-field"                 ,  0, KW_GET_U_F , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-value"                      ,  0, KW_GET_VAL , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("get-value-by-index"             ,  0, KW_GET_VBI , false),
             new Keyword("get-value-by-namespace-name"    ,  0, KW_GET_VBNN, false),
             new Keyword("get-value-by-qname"             ,  0, KW_GET_VBQN, false),
             new Keyword("get-wait-state"                 ,  0, KW_GET_WAIT, false),
             new Keyword("get-working-directory"          ,  0, KW_GET_WKDR, false),  // FWD extension, not real 4GL!
             new Keyword("getsignatureimage"              ,  0, KW_GET_SIMG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("global"                         ,  0, KW_GLOBAL  , true ),
             new Keyword("gt"                             ,  0, KW_GT      , false),
             new Keyword("go"                             ,  0, KW_GO      , false),
             new Keyword("go-on"                          ,  0, KW_GO_ON   , true ),
             new Keyword("go-pending"                     ,  7, KW_GO_PEND , true ),
             new Keyword("go-to"                          ,  0, KW_GOTO    , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("grant"                          ,  0, KW_GRANT   , true ),
             new Keyword("graphic-edge"                   ,  9, KW_GRAPHIC , true ),
             new Keyword("grid-factor-horizontal"         , 13, KW_GRD_F_H , false),
             new Keyword("grid-factor-vertical"           , 13, KW_GRD_F_V , false),
             new Keyword("grid-snap"                      ,  0, KW_GRD_SNAP, false),
             new Keyword("grid-unit-height-chars"         , 16, KW_GRD_UHC , false),
             new Keyword("grid-unit-height-pixels"        , 18, KW_GRD_UHP , false),
             new Keyword("grid-unit-width-chars"          , 15, KW_GRD_UWC , false),
             new Keyword("grid-unit-width-pixels"         , 17, KW_GRD_UWP , false),
             new Keyword("grid-visible"                   ,  0, KW_GRD_VIS , false),
             new Keyword("group"                          ,  0, KW_GROUP   , true ),
             new Keyword("group-box"                      ,  0, KW_GROUP_BX, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("guid"                           ,  0, KW_GUID    , false),
             new Keyword("h-scroll-position"              ,  0, KW_H_SCRL_P, false),  // FWD extension, not a real 4GL keyword
             new Keyword("handle"                         ,  0, KW_HANDLE  , false),
             new Keyword("handler"                        ,  0, KW_HANDLER , false),
             new Keyword("has-lobs"                       ,  0, KW_HAS_LOBS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("has-records"                    ,  0, KW_HAS_REC , false),
             new Keyword("hash-code"                      ,  0, KW_HASHCODE, true ),
             new Keyword("having"                         ,  0, KW_HAVING  , true ),
             new Keyword("header"                         ,  0, KW_HEADER  , true ),
             new Keyword("height-chars"                   ,  6, KW_HEIGHT_C, false),
             new Keyword("height-pixels"                  ,  8, KW_HEIGHT_P, false),
             new Keyword("help"                           ,  0, KW_HELP    , true ),
             new Keyword("help-topic"                     ,  0, KW_HELP_TOP, false),
             new Keyword("hex-decode"                     ,  0, KW_HEX_DECD, false),
             new Keyword("hex-encode"                     ,  0, KW_HEX_ENCD, false),
             new Keyword("hide"                           ,  0, KW_HIDE    , true ),
             new Keyword("hidden-field"                   ,  0, KW_HID_FLD , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("hidden-field-list"              ,  0, KW_HID_FLDL, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("hidden"                         ,  0, KW_HIDDEN  , false),
             new Keyword("hint"                           ,  0, KW_HINT    , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("hit-test"                       ,  0, KW_HIT_TEST, false),  // FWD extension, not a real 4GL keyword
             new Keyword("hit-test-fwd"                   ,  0, KW_HIT_TFWD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("home"                           ,  0, KW_HOME    , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("horizontal"                     ,  4, KW_HORIZ   , false),
             new Keyword("host-byte-order"                ,  0, KW_HOST_B_O, true ),
             new Keyword("html-browser"                   ,  0, KW_HTML_BWS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("html-charset"                   ,  0, KW_HTML_CHS, false),
             new Keyword("html-encode"                    ,  0, KW_HTML_ENC, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("html-end-of-line"               ,  0, KW_HTML_EOL, false),
             new Keyword("html-end-of-page"               ,  0, KW_HTML_EOP, false),
             new Keyword("html-frame-begin"               ,  0, KW_HTML_FRB, false),
             new Keyword("html-frame-end"                 ,  0, KW_HTML_FRE, false),
             new Keyword("html-header-begin"              ,  0, KW_HTML_H_B, false),
             new Keyword("html-header-end"                ,  0, KW_HTML_H_E, false),
             new Keyword("html-title-begin"               ,  0, KW_HTML_T_B, false),
             new Keyword("html-title-end"                 ,  0, KW_HTML_T_E, false),
             new Keyword("htmlerror"                      ,  0, KW_HTMLERR , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("hwnd"                           ,  0, KW_HWND    , false),
             new Keyword("hyperlink"                      ,  0, KW_HYPERLNK, false),  // FWD extension, not a real 4GL keyword
             new Keyword("honorprokeys"                   ,  0, KW_HONOR_PK, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("honorreturnkey"                 ,  0, KW_HONOR_RK, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("icon"                           ,  0, KW_ICON    , false),
             new Keyword("ide-parent-hwnd"                ,  0, KW_IDEPHWND, false),
             new Keyword("ide-window-type"                ,  0, KW_IDEWNTYP, false),
             new Keyword("ignore-current-modified"        ,  0, KW_IGN_CMOD, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("if"                             ,  0, KW_IF      , true ),
             new Keyword("icfparameter"                   ,  8, KW_ICFPARM , false),  // undocumented feature: can be abbreviated
             new Keyword("image"                          ,  0, KW_IMAGE   , false),
             new Keyword("image-down"                     ,  0, KW_IMG_DOWN, false),
             new Keyword("image-insensitive"              ,  0, KW_IMG_INS , false),
             new Keyword("image-list"                     ,  0, KW_IMG_LIST, false),  // FWD extension, not a real 4GL keyword
             new Keyword("image-only"                     ,  0, KW_IMG_ONLY, false),  // FWD extension, not a real 4GL keyword
             new Keyword("imagelist"                      ,  0, KW_IL_IMG  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-back-color"                  ,  0, KW_IL_BGCOL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-image-height"                ,  0, KW_IL_HEIGH, false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-image-width"                 ,  0, KW_IL_WIDTH, false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-list-images"                 ,  0, KW_IL_LIST , false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-mask-color"                  ,  0, KW_IL_MASK , false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-overlay"                     ,  0, KW_IL_OVER , false),  // FWD extension, not a real 4GL keyword
             new Keyword("il-use-mask-color"              ,  0, KW_IL_UMASK, false),  // FWD extension, not a real 4GL keyword
             new Keyword("image-size"                     ,  0, KW_IMG_SZ  , false),
             new Keyword("image-size-chars"               , 12, KW_IMG_SZ_C, false),
             new Keyword("image-size-pixels"              , 12, KW_IMG_SZ_P, false),
             new Keyword("image-up"                       ,  0, KW_IMG_UP  , false),
             new Keyword("immediate-display"              ,  0, KW_IMM_DISP, false),
             new Keyword("implements"                     ,  0, KW_IMPLEMTS, false),
             new Keyword("import"                         ,  0, KW_IMPORT  , true ),
             new Keyword("import-principal"               ,  0, KW_IMP_PRNC, false),
             new Keyword("import-node"                    ,  0, KW_IMP_NODE, false),
             new Keyword("in"                             ,  0, KW_IN      , true ),
             new Keyword("in-handle"                      ,  0, KW_IN_HNDL , false),
             new Keyword("increment-exclusive-id"         ,  0, KW_INC_EX_I, false),
             new Keyword("indentation"                    ,  0, KW_INDENT  , false ),  // FWD extension, not a real 4GL keyword
             new Keyword("index"                          ,  0, KW_INDEX   , true ),
             new Keyword("index-hint"                     ,  0, KW_IDX_HINT, false),
             new Keyword("index-information"              ,  0, KW_IDX_INFO, false),
             new Keyword("indexed-reposition"             ,  0, KW_IDX_REPO, false),
             new Keyword("indicator"                      ,  0, KW_INDICAT , true ),
             new Keyword("information"                    ,  4, KW_INFO    , false),
             new Keyword("inherits"                       ,  0, KW_INHERITS, false),
             new Keyword("inherit-bgcolor"                ,  0, KW_INH_BGC , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("inherit-fgcolor"                ,  0, KW_INH_FGC , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("init-session"                   ,  0, KW_INIT_SES, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("initial"                        ,  4, KW_INIT    , false),
             new Keyword("initial-dir"                    ,  0, KW_INIT_DIR, false),
             new Keyword("initial-filter"                 ,  0, KW_INIT_FLT, false),
             new Keyword("initialize"                     ,  0, KW_INIT_C_P, false), // CLIENT-PRINCIPAL:INITALIZE method
             new Keyword("initialize-document-type"       ,  0, KW_INIT_D_T, false),
             new Keyword("initiate"                       ,  0, KW_INITIATE, false),
             new Keyword("inner-chars"                    ,  0, KW_INNER_C , false),
             new Keyword("inner-lines"                    ,  0, KW_INNER_L , false),
             new Keyword("inner"                          ,  0, KW_INNER   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("input"                          ,  0, KW_INPUT   , true ),
             new Keyword("input-output"                   ,  7, KW_IN_OUT  , true ),
             new Keyword("input-value"                    ,  0, KW_INPT_VAL, false),
             new Keyword("insert"                         ,  0, KW_INSERT  , true ),
             new Keyword("insert-attribute"               ,  0, KW_INS_ATTR, false),
             new Keyword("insert-backtab"                 ,  8, KW_INS_BTAB, false),
             new Keyword("insert-before"                  ,  0, KW_INS_B4  , false),
             new Keyword("insert-column"                  ,  0, KW_INS_COL , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("insert-file"                    ,  0, KW_INS_FILE, false),
             new Keyword("insert-field"                   ,  0, KW_INS_FLD , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("insert-field-data"              ,  0, KW_INS_FLDD, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("insert-field-label"             ,  0, KW_INS_FLDL, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("insert-mode"                    ,  0, KW_INS_MODE, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("insert-row"                     ,  0, KW_INS_ROW , false),
             new Keyword("insert-string"                  ,  0, KW_INS_STR , false),
             new Keyword("insert-tab"                     ,  8, KW_INS_TAB , false),
             new Keyword("instantiating-procedure"        ,  0, KW_INST_PRC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("int64"                          ,  0, KW_INT64   , false),
             new Keyword("integer"                        ,  3, KW_INT     , false),
             new Keyword("interface"                      ,  0, KW_INTERFAC, false),
             new Keyword("internal-entries"               ,  0, KW_INT_ENT , false),
             new Keyword("interval"                       ,  0, KW_INTERVAL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("into"                           ,  0, KW_INTO    , true ),
             new Keyword("invoke"                         ,  0, KW_INVOKE  , false),
             new Keyword("ip-capture-time"                ,  0, KW_IP_TIME , false),  // FWD extension, not a real 4GL keyword
             new Keyword("is"                             ,  0, KW_IS      , true ),
             new Keyword("is-db-multi-tenant"             ,  0, KW_IS_DB_MT, false),  // latest language reference includes this
             new Keyword("is-attr-space"                  ,  7, KW_IS_ATTR , true ),
             new Keyword("is-class"                       ,  7, KW_IS_CLASS, false),
             new Keyword("is-codepage-fixed"              ,  0, KW_IS_CP_FX, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("is-column-codepage"             ,  0, KW_IS_COLCP, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("is-column-visible"              ,  0, KW_IS_C_VIS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("is-json"                        ,  0, KW_IS_JSON,  false),
             new Keyword("is-lead-byte"                   ,  0, KW_IS_LEAD , true ),
             new Keyword("is-multi-select"                ,  0, KW_IS_MSEL,  false),  // FWD extension, not a real 4GL keyword
             new Keyword("is-multi-tenant"                ,  0, KW_IS_M_TEN, false),  // missing in keyword index, found in customer code
             new Keyword("is-node-expanded"               ,  0, KW_IS_N_EXP, false),  // FWD extension, not a real 4GL keyword
             new Keyword("is-open"                        ,  0, KW_IS_OPEN , false),
             new Keyword("is-parameter-set"               ,  0, KW_IS_P_SET, false),
             new Keyword("is-partitioned"                 , 13, KW_IS_PART , false),
             new Keyword("is-row-selected"                ,  0, KW_IS_R_SEL, false),
             new Keyword("is-selected"                    ,  0, KW_IS_SEL  , false),
             new Keyword("is-xml"                         ,  0, KW_IS_XML  , false),  // missing from keyword index, found elsewhere in lang ref
             new Keyword("iso-date"                       ,  0, KW_ISO_DATE, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("item"                           ,  0, KW_ITEM    , false),
             new Keyword("items-per-row"                  ,  0, KW_ITEM_ROW, false),
             new Keyword("iteration-changed"              ,  0, KW_ITER_CHG, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("iunknown"                       ,  0, KW_IUNKNOWN, false),  // missing in keyword index, found elsewhere in external program interface ref
             new Keyword("java"                           ,  0, KW_JAVA    , false),  // FWD extension, not a real 4GL keyword
             new Keyword("join"                           ,  0, KW_JOIN    , true ),
             new Keyword("join-by-sqldb"                  ,  0, KW_JOIN_BY , false),
             new Keyword("kblabel"                        ,  0, KW_KBLABEL , true ),
             new Keyword("keep-connection-open"           ,  0, KW_KEEP_CON, false),
             new Keyword("keep-frame-z-order"             , 12, KW_KEEP_ZOR, false),
             new Keyword("keep-messages"                  ,  0, KW_KEEP_MSG, false),
             new Keyword("keep-security-cache"            ,  0, KW_KEEP_SEC, false),
             new Keyword("keep-tab-order"                 ,  0, KW_KEEP_TAB, false),
             new Keyword("keycode"                        ,  0, KW_KEYCODE , true ),
             new Keyword("key-code"                       ,  0, KW_KEYCODE , true ),
             new Keyword("keyfunction"                    ,  7, KW_KEYFUNC , true ),
             new Keyword("key-function"                   ,  8, KW_KEYFUNC , true ),
             new Keyword("keylabel"                       ,  0, KW_KEYLAB  , true ),
             new Keyword("key-label"                      ,  0, KW_KEYLAB  , true ),
             new Keyword("key"                            ,  0, KW_KEY     , false),
             new Keyword("keypadaddhotspot"               ,  0, KW_KPAD_HOT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("keypadclearhotspotlist"         ,  0, KW_KPAD_CLE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("keypadqueryhotspot"             ,  0, KW_KPAD_QRY, false),  // FWD extension, not a real 4GL keyword
             new Keyword("keys"                           ,  0, KW_KEYS    , true ),
             new Keyword("keyword"                        ,  0, KW_KW      , true ),
             new Keyword("keyword-all"                    ,  0, KW_KW_ALL  , false),
             new Keyword("label"                          ,  0, KW_LABEL   , true ),
             new Keyword("label-bgcolor"                  ,  9, KW_LAB_BGC , false),
             new Keyword("label-dcolor"                   ,  8, KW_LAB_DC  , false),
             new Keyword("label-fgcolor"                  ,  9, KW_LAB_FGC , false),
             new Keyword("label-font"                     ,  0, KW_LAB_FONT, false),
             new Keyword("label-pfcolor"                  ,  9, KW_LAB_PFC , false),
             new Keyword("labels"                         ,  0, KW_LABELS  , false),
             new Keyword("labels-have-colons"             ,  0, KW_LAB_H_C , false),
             new Keyword("landscape"                      ,  0, KW_LANDSCAP, false),
             new Keyword("languages"                      ,  8, KW_LANGUAGE, false),
             new Keyword("large"                          ,  0, KW_LARGE   , false),
             new Keyword("large-to-small"                 ,  0, KW_LG_2_SM , false),
             new Keyword("last"                           ,  0, KW_LAST    , true ),
             new Keyword("last-batch"                     ,  0, KW_LAST_BAT, false),
             new Keyword("last-form"                      ,  0, KW_LAST_FRM, false),
             new Keyword("last-object"                    ,  0, KW_LAST_OBJ, false),
             new Keyword("last-of"                        ,  0, KW_LAST_OF , true ),
             new Keyword("lastkey"                        ,  0, KW_LASTKEY , true ),
             new Keyword("last-key"                       ,  0, KW_LASTKEY , true ),
             new Keyword("last-async-request"             ,  0, KW_LAST_AR , false),
             new Keyword("last-child"                     ,  0, KW_LAST_CH , false),
             new Keyword("last-event"                     ,  9, KW_LAST_EVT, true ),
             new Keyword("last-procedure"                 , 10, KW_LAST_PRC, false),
             new Keyword("last-server"                    ,  0, KW_LAST_SRV, false),
             new Keyword("last-server-socket"             ,  0, KW_LAST_SS , false),
             new Keyword("last-socket"                    ,  0, KW_LAST_SOC, false),
             new Keyword("last-tab-item"                  , 10, KW_LAST_TI , false),
             new Keyword("ldbname"                        ,  0, KW_LDBNAME , true ),
             new Keyword("lower"                          ,  0, KW_LC      , false),  // missing in keyword index, found elsewhere in SQL reference
             new Keyword("lc"                             ,  0, KW_LC      , false),
             new Keyword("lcdrefresh"                     ,  0, KW_LCD_REFR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("lcdsetwindow"                   ,  0, KW_LCD_SWIN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("lcdwritestring"                 ,  0, KW_LCD_WSTR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("le"                             ,  0, KW_LTE     , false),
             new Keyword("leave"                          ,  0, KW_LEAVE   , true ),
             new Keyword("left"                           ,  0, KW_LEFT    , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("left-aligned"                   , 10, KW_LEFT_AL , false),
             new Keyword("left-end"                       ,  0, KW_LEFT_END, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("left-mouse-click"               ,  0, KW_LEFT_MC , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("left-mouse-dblclick"            ,  0, KW_LEFT_MDC, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("left-mouse-down"                ,  0, KW_LEFT_MD , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("left-mouse-up"                  ,  0, KW_LEFT_MU , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("left-trim"                      ,  0, KW_L_TRIM  , false),
             new Keyword("length"                         ,  0, KW_LENGTH  , false),
             new Keyword("library"                        ,  0, KW_LIB     , true ),
             new Keyword("library-calling-convention"     ,  0, KW_LIB_C_C , false),
             new Keyword("like"                           ,  0, KW_LIKE    , true ),
             new Keyword("like-sequential"                ,  0, KW_LIKE_SEQ, true ),
             new Keyword("line"                           ,  0, KW_LINE    , false),
             new Keyword("line-counter"                   , 10, KW_LINE_CNT, true ),
             new Keyword("list-events"                    ,  0, KW_LST_EVNT, false),
             new Keyword("listing"                        ,  5, KW_LISTING , true ),
             new Keyword("listings"                       ,  0, KW_LISTINGS, false),  // missing from keyword index, found in customer code and UNTESTED at this time
             new Keyword("list-item-pairs"                ,  0, KW_LST_PAIR, false),
             new Keyword("list-items"                     ,  0, KW_LIST_ITM, false),
             new Keyword("list-property-names"            ,  0, KW_LIST_PNM, false),
             new Keyword("list-query-attrs"               ,  0, KW_LST_QRY , false),
             new Keyword("list-set-attrs"                 ,  0, KW_LST_SET , false),
             new Keyword("list-widgets"                   ,  0, KW_LST_WID , false),
             new Keyword("literal-question"               ,  0, KW_LIT_QSTN, false),
             new Keyword("little-endian"                  ,  0, KW_L_ENDIAN, true ),
             new Keyword("lt"                             ,  0, KW_LT      , false),
             new Keyword("load"                           ,  0, KW_LOAD    , false),
             new Keyword("loadcontrols"                   ,  0, KW_LOADCTRL, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("load-domains"                   ,  0, KW_LOAD_DMN, false),
             new Keyword("load-icon"                      ,  0, KW_LOAD_ICO, false),
             new Keyword("load-image"                     ,  0, KW_LOAD_IMG, false),
             new Keyword("load-image-down"                ,  0, KW_LOAD_I_D, false),
             new Keyword("load-image-insensitive"         ,  0, KW_LOAD_I_I, false),
             new Keyword("load-image-up"                  ,  0, KW_LOAD_I_U, false),
             new Keyword("load-mouse-pointer"             , 12, KW_LOAD_M_P, false),
             new Keyword("load-picture"                   ,  0, KW_LOAD_PIC, false),
             new Keyword("load-small-icon"                ,  0, KW_LOAD_S_I, false),
             new Keyword("lob-dir"                        ,  0, KW_LOB_DIR , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("local-host"                     ,  0, KW_LOC_HOST, false),
             new Keyword("local-name"                     ,  0, KW_LOC_NAME, false),
             new Keyword("local-port"                     ,  0, KW_LOC_PORT, false),
             new Keyword("local-version-info"             ,  0, KW_LOC_V_I , false),
             new Keyword("locator-column-number"          ,  0, KW_LOC_C_N , false),
             new Keyword("locator-line-number"            ,  0, KW_LOC_L_N , false),
             new Keyword("locator-public-id"              ,  0, KW_LOC_P_ID, false),
             new Keyword("locator-system-id"              ,  0, KW_LOC_S_ID, false),
             new Keyword("locator-type"                   ,  0, KW_LOC_TYPE, false),
             new Keyword("locked"                         ,  0, KW_LOCKED  , true ),
             new Keyword("lock-registration"              ,  0, KW_LOCK_REG, false),
             new Keyword("log"                            ,  0, KW_LOG     , false),
             new Keyword("log-audit-event"                ,  0, KW_LOG_A_EV, false),
             new Keyword("log-entry-types"                ,  0, KW_LOG_EN_T, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("log-id"                         ,  0, KW_LOG_ID  , false),  // missing from keyword index and found in customer code
             new Keyword("log-manager"                    ,  0, KW_LOG_MGR , true ),
             new Keyword("log-threshold"                  ,  0, KW_LOG_THRS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("logfile-name"                   ,  0, KW_LOGF_NAM, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("logging-level"                  ,  0, KW_LOGG_LEV, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("logical"                        ,  4, KW_LOGICAL , false),
             new Keyword("login-expiration-timestamp"     ,  0, KW_LOG_E_TS, false),
             new Keyword("login-host"                     ,  0, KW_LOG_HOST, false),
             new Keyword("login-state"                    ,  0, KW_LOG_STAT, false),
             new Keyword("logout"                         ,  0, KW_LOGOUT  , false),
             new Keyword("lookahead"                      ,  0, KW_LOOKAHD , false),
             new Keyword("lookup"                         ,  0, KW_LOOKUP  , true ),
             new Keyword("long"                           ,  0, KW_LONG    , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("longchar"                       ,  0, KW_LONGCHAR, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("longchar-to-node-value"         ,  0, KW_LCHR_2NV, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("machine-class"                  ,  0, KW_MACH_CLS, true ),
             new Keyword("main-menu"                      ,  0, KW_MAINMENU, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("mandatory"                      ,  0, KW_MAND    , false),
             new Keyword("manual-highlight"               ,  0, KW_MAN_HIGH, false),
             new Keyword("margin-extra"                   ,  0, KW_MARG_EX , false),  // found in keyword index, this is an undocumented DEFINE BUTTON option
             new Keyword("margin-height-chars"            , 13, KW_MARG_H_C, false),
             new Keyword("margin-height-pixels"           , 15, KW_MARG_H_P, false),
             new Keyword("margin-width-chars"             , 12, KW_MARG_W_C, false),
             new Keyword("margin-width-pixels"            , 14, KW_MARG_W_P, false),
             new Keyword("mark-new"                       ,  0, KW_MARK_NEW, false),
             new Keyword("mark-row-state"                 ,  0, KW_MARK_RS , false),
             new Keyword("maximum"                        ,  3, KW_MAX     , false),  // handles "separate keyword" max too
             new Keyword("maximize"                       ,  0, KW_MAXIMIZE, false),
             new Keyword("max-button"                     ,  0, KW_MAX_BTN , false),
             new Keyword("max-chars"                      ,  0, KW_MAX_CHAR, false),
             new Keyword("max-data-guess"                 ,  0, KW_MAX_D_G , false),
             new Keyword("max-height"                     ,  0, KW_MAX_HT  , false),
             new Keyword("max-height-chars"               , 12, KW_MAX_H_C , false),
             new Keyword("max-height-pixels"              , 12, KW_MAX_H_P , false),
             new Keyword("maximum-level"                  ,  0, KW_MAX_LVL , false),
             new Keyword("max-width-chars"                ,  9, KW_MAX_W_C , false),
             new Keyword("max-width-pixels"               , 11, KW_MAX_W_P , false),
             new Keyword("max-rows"                       ,  0, KW_MAX_ROWS, false),
             new Keyword("max-size"                       ,  0, KW_MAX_SZ  , false),
             new Keyword("max-value"                      ,  7, KW_MAX_VAL , false),
             new Keyword("max-width"                      ,  0, KW_MAX_WID , false),
             new Keyword("map"                            ,  0, KW_MAP     , true ),
             new Keyword("matches"                        ,  0, KW_MATCHES , false),
             new Keyword("md5-value"                      ,  0, KW_MD5_VAL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("md5-digest"                     ,  0, KW_MD5_DIG , false),
             new Keyword("member"                         ,  0, KW_MEMBER  , true ),
             new Keyword("memptr"                         ,  3, KW_MEMPTR  , false),
             new Keyword("memptr-to-node-value"           ,  0, KW_MPTR_2NV, false),
             new Keyword("menu"                           ,  0, KW_MENU    , false),
             new Keyword("menu-bar"                       ,  0, KW_MENU_BAR, false),
             new Keyword("menu-drop"                      ,  0, KW_MENU_DRP, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("menu-key"                       ,  6, KW_MENU_KEY, false),
             new Keyword("menu-mouse"                     ,  6, KW_MENU_MOU, false),
             new Keyword("menubar"                        ,  0, KW_MENU_BAR, false),
             new Keyword("menu-item"                      ,  0, KW_MENU_ITM, false),
             new Keyword("merge-by-field"                 ,  0, KW_MERGE_BF, false),
             new Keyword("merge-changes"                  ,  0, KW_MERGE_CH, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("merge-row-changes"              ,  0, KW_MERGE_RC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("message"                        ,  0, KW_MSG     , true ),
             new Keyword("messages"                       ,  0, KW_MESSAGES, false),
             new Keyword("message-area"                   ,  0, KW_MSG_AREA, false),
             new Keyword("message-area-font"              ,  0, KW_MSG_AFNT, false),
             new Keyword("message-area-msg"               ,  0, KW_MSG_AMSG, false),  // missing from keyword index, undocumented SESSION method found in customer application
             new Keyword("message-digest"                 ,  0, KW_MSG_DIG , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("message-lines"                  ,  0, KW_MSG_LINE, true ),
             new Keyword("method"                         ,  0, KW_METHOD  , false),
             new Keyword("mf-draw-filled-rect"            ,  0, KW_MF_DFR  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-image"                  ,  0, KW_MF_DI   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-image-part"             ,  0, KW_MF_DIP  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-line"                   ,  0, KW_MF_DL   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-rect"                   ,  0, KW_MF_DR   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text"                   ,  0, KW_MF_DT   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-and-set-x"         ,  0, KW_MF_DTSX , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-at-x"              ,  0, KW_MF_DTAX , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-at-x-left"         ,  0, KW_MF_DTAXL, false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-at-x-right"        ,  0, KW_MF_DTAXR, false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-between"           ,  0, KW_MF_DTB  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-between-left"      ,  0, KW_MF_DTBL , false),  // FWD extension, not real 4GL!
             new Keyword("mf-draw-text-between-right"     ,  0, KW_MF_DTBR , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-font"                    ,  0, KW_MF_GF   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-font-height"             ,  0, KW_MF_GFH  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-free-space-down"         ,  0, KW_MF_GFSD , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-free-space-right"        ,  0, KW_MF_GFSR , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-page-height"             ,  0, KW_MF_GPH  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-page-number"             ,  0, KW_MF_GPN  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-page-width"              ,  0, KW_MF_GPW  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-text-width"              ,  0, KW_MF_GTW  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-xy"                      ,  0, KW_MF_GXY  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-get-zoom-factor"             ,  0, KW_MF_GZF  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-init"                        ,  0, KW_MF_INIT , false),  // FWD extension, not real 4GL!
             new Keyword("mf-interrupt-recording"         ,  0, KW_MF_IR   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-make-pdf"                    ,  0, KW_MF_MPDF , false),  // FWD extension, not real 4GL!
             new Keyword("mf-pixels-to-metafile-units"    ,  0, KW_MF_P2MU , false),  // FWD extension, not real 4GL!
             new Keyword("mf-reset-page"                  ,  0, KW_MF_RP   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-fill-color"              ,  0, KW_MF_SFC  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-font"                    ,  0, KW_MF_SF   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-font-height"             ,  0, KW_MF_SFH  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-image-align"             ,  0, KW_MF_SIA  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-interleaving"            ,  0, KW_MF_SI   , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-left-margin"             ,  0, KW_MF_SLM  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-line-attributes"         ,  0, KW_MF_SLA  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-line-color"              ,  0, KW_MF_SLC  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-line-style"              ,  0, KW_MF_SLS  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-page-number"             ,  0, KW_MF_SPN  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-page-number-position"    ,  0, KW_MF_SPNP , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-page-number-text"        ,  0, KW_MF_SPNT , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-page-orientation"        ,  0, KW_MF_SPO  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-text-align"              ,  0, KW_MF_STA  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-text-color"              ,  0, KW_MF_STC  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-text-style"              ,  0, KW_MF_STS  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-xy"                      ,  0, KW_MF_SXY  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-set-zoom-factor"             ,  0, KW_MF_SZF  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-show-page-footer"            ,  0, KW_MF_SPF  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-start-new-page"              ,  0, KW_MF_SNP  , false),  // FWD extension, not real 4GL!
             new Keyword("mf-start-new-text-line"         ,  0, KW_MF_SNTL , false),  // FWD extension, not real 4GL!
             new Keyword("mf-stop-recording"              ,  0, KW_MF_SR   , false),  // FWD extension, not real 4GL!
             new Keyword("middle-mouse-click"             ,  0, KW_MDL_MC  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("middle-mouse-dblclick"          ,  0, KW_MDL_MDC , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("middle-mouse-down"              ,  0, KW_MDL_MD  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("middle-mouse-up"                ,  0, KW_MDL_MU  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("minimum"                        ,  3, KW_MIN     , false),  // handles "separate keyword" min too
             new Keyword("min-button"                     ,  0, KW_MIN_BTN , false),
             new Keyword("min-column-width-chars"         ,  0, KW_MIN_CWCH, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("min-column-width-pixels"        ,  0, KW_MIN_CWPX, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("min-height-chars"               , 10, KW_MIN_H_C , false),
             new Keyword("min-height-pixels"              , 12, KW_MIN_H_P , false),
             new Keyword("min-schema-marshal"             ,  0, KW_MIN_SCHM, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("min-width-chars"                ,  9, KW_MIN_W_C , false),
             new Keyword("min-width-pixels"               , 11, KW_MIN_W_P , false),
             new Keyword("min-size"                       ,  0, KW_MIN_SZ  , false),
             new Keyword("min-value"                      ,  7, KW_MIN_VAL , false),
             new Keyword("mnemonic"                       ,  0, KW_MNEMON  , false), // FWD extension, not real 4GL!
             new Keyword("modulo"                         ,  3, KW_MOD     , false),
             new Keyword("modified"                       ,  0, KW_MODIFIED, false),
             new Keyword("modifiers"                      ,  0, KW_MODIFIRS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("month"                          ,  0, KW_MONTH   , false),
             new Keyword("mouse"                          ,  0, KW_MOUSE   , true ),
             new Keyword("mouse-extend-click"             ,  0, KW_MOU_XC  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-extend-dblclick"          ,  0, KW_MOU_XDC , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-extend-down"              ,  0, KW_MOU_XD  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-extend-up"                ,  0, KW_MOU_XU  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-menu-click"               ,  0, KW_MOU_MC  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-menu-dblclick"            ,  0, KW_MOU_MDC , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-menu-down"                ,  0, KW_MOU_MD  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-menu-up"                  ,  0, KW_MOU_MU  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-move-click"               ,  0, KW_MOU_MVC , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-move-dblclick"            ,  0, KW_MOU_MVDC, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-move-down"                ,  0, KW_MOU_MVD , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-move-up"                  ,  0, KW_MOU_MVU , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-pointer"                  ,  7, KW_MOU_PTR , false),
             new Keyword("mouse-select-click"             ,  0, KW_MOU_SC  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-select-dblclick"          ,  0, KW_MOU_SDC , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-select-down"              ,  0, KW_MOU_SD  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-select-up"                ,  0, KW_MOU_SU  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("mouse-click"                    ,  0, KW_MS_CLICK, false),  // FWD extension, not a real 4GL keyword
             new Keyword("mouse-dblclick"                 ,  0, KW_MS_DBCLK, false),  // FWD extension, not a real 4GL keyword
             new Keyword("mouse-down"                     ,  0, KW_MS_DOWN , false),  // FWD extension, not a real 4GL keyword
             new Keyword("mouse-move"                     ,  0, KW_MS_MOVE , false),  // FWD extension, not a real 4GL keyword
             new Keyword("mouse-up"                       ,  0, KW_MS_UP   , false),  // FWD extension, not a real 4GL keyword
             new Keyword("movable"                        ,  0, KW_MOVABLE , false),
             new Keyword("move"                           ,  0, KW_MOVE    , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("move-after-tab-item"            , 10, KW_MOV_A_T , false),
             new Keyword("move-before-tab-item"           , 10, KW_MOV_B_T , false),
             new Keyword("move-column"                    ,  8, KW_MOV_COL , false),
             new Keyword("move-down-in-parent"            ,  0, KW_M_D_I_P , false),  // FWD extension, not a real 4GL keyword
             new Keyword("move-up-in-parent"              ,  0, KW_M_U_I_P , false),  // FWD extension, not a real 4GL keyword
             new Keyword("move-to-bottom"                 ,  9, KW_MOV_2_B , false),
             new Keyword("move-to-eof"                    ,  0, KW_MOV_2EOF, false),
             new Keyword("move-to-top"                    ,  9, KW_MOV_2_T , false),
             new Keyword("mpe"                            ,  0, KW_MPE     , true ),
             new Keyword("mtime"                          ,  0, KW_MTIME   , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("multi-compile"                  ,  0, KW_MULT_CMP, false),
             new Keyword("multi-line"                     ,  0, KW_TAB_ML,   false),  // FWD extension, not a real 4GL keyword
             new Keyword("multiple"                       ,  0, KW_MULTIPLE, false),
             new Keyword("multiple-key"                   ,  0, KW_MULT_KEY, false),
             new Keyword("multitasking-interval"          ,  0, KW_MULTI_IN, false),
             new Keyword("must-exist"                     ,  0, KW_MUST_EXI, false),
             new Keyword("must-understand"                ,  0, KW_MUST_UND, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("name"                           ,  0, KW_NAME    , false),
             new Keyword("namespace-prefix"               ,  0, KW_NAMESP_P, false),
             new Keyword("namespace-uri"                  ,  0, KW_NAMESP_U, false),
             new Keyword("native"                         ,  0, KW_NATIVE  , false),
             new Keyword("ne"                             ,  0, KW_NE      , false),
             new Keyword("needs-appserver-prompt"         ,  0, KW_NEEDS_AP, false),
             new Keyword("needs-prompt"                   ,  0, KW_NEEDS_PR, false),
             new Keyword("nested"                         ,  0, KW_NESTED  , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("new"                            ,  0, KW_NEW     , true ),
             new Keyword("new-instance"                   ,  0, KW_NEW_INST, false),
             new Keyword("new-label"                      ,  0, KW_NEW_LBL,  false),  // FWD extension, not a real 4GL keyword
             new Keyword("new-line"                       ,  0, KW_NEW_LINE, false),  // missing in keyword index, found in customer source code
             new Keyword("new-row"                        ,  0, KW_NEW_ROW , false),
             new Keyword("new-session"                    ,  0, KW_NEW_SESS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("next"                           ,  0, KW_NEXT    , true ),
             new Keyword("next-column"                    ,  0, KW_NEXT_COL, false),
             new Keyword("next-error"                     ,  0, KW_NEXT_ERR, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("next-frame"                     ,  0, KW_NEXT_FR , false),
             new Keyword("next-prompt"                    ,  0, KW_NEXT_PMT, true ),
             new Keyword("next-rowid"                     ,  0, KW_NEXT_RID, false),
             new Keyword("next-sibling"                   ,  0, KW_NEXT_SIB, false),
             new Keyword("next-tab-item"                  , 10, KW_NEXT_TAB, false),
             new Keyword("next-value"                     ,  0, KW_NEXT_VAL, false),
             new Keyword("next-word"                      ,  0, KW_NEXTWORD, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("no"                             ,  0, BOOL_FALSE , true ),
             new Keyword("no-apply"                       ,  0, KW_NO_APPLY, false),
             new Keyword("no-array-message"               ,  0, KW_NO_ARMSG, false),
             new Keyword("no-assign"                      ,  0, KW_NO_ASSGN, false),
             new Keyword("no-attr-list"                   ,  7, KW_NO_ATTRL, true ),
             new Keyword("no-attr-space"                  ,  7, KW_NO_ATTR , true ),
             new Keyword("no-auto-validate"               ,  0, KW_NO_AUTOV, false),
             new Keyword("no-bind-where"                  ,  0, KW_NO_BIND , false),
             new Keyword("no-box"                         ,  0, KW_NO_BOX  , false),
             new Keyword("no-column-scrolling"            ,  0, KW_NO_COLS , false),  // missing in keyword index, found in customer source code.
             new Keyword("no-console"                     ,  0, KW_NO_CONS , false),
             new Keyword("no-convert"                     ,  0, KW_NO_CVT  , false),
             new Keyword("no-convert-3d-colors"           ,  0, KW_NO_CV_3D, false),
             new Keyword("no-current-value"               ,  0, KW_NO_CUR_V, false),
             new Keyword("no-debug"                       ,  0, KW_NO_DEBUG, false),
             new Keyword("no-drag"                        ,  0, KW_NO_DRAG , false),
             new Keyword("no-echo"                        ,  0, KW_NO_ECHO , false),
             new Keyword("no-empty-space"                 ,  0, KW_NO_EM_SP, false),
             new Keyword("no-enhanced-filtering"          ,  0, KW_NO_EH_FL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("no-enhanced-sorting"            ,  0, KW_NO_EH_SR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("no-error"                       ,  0, KW_NO_ERROR, true ),
             new Keyword("no-fill"                        ,  4, KW_NO_FILL , true ),
             new Keyword("no-focus"                       ,  0, KW_NO_FOCUS, true ),
             new Keyword("no-help"                        ,  0, KW_NO_HELP , false),
             new Keyword("no-hide"                        ,  0, KW_NO_HIDE , true ),
             new Keyword("no-index-hint"                  ,  0, KW_NO_IDX_H, false),
             new Keyword("no-inherit-bgcolor"             , 14, KW_NO_INHBG, false),
             new Keyword("no-inherit-fgcolor"             , 14, KW_NO_INHFG, false),
             new Keyword("no-join-by-sqldb"               ,  0, KW_NO_JOIN , false),
             new Keyword("no-labels"                      ,  8, KW_NO_LABEL, true ),
             new Keyword("no-lobs"                        ,  0, KW_NO_LOBS , true ),
             new Keyword("no-lock"                        ,  0, KW_NO_LOCK , true ),
             new Keyword("no-lookahead"                   ,  0, KW_NO_LOOKA, false),
             new Keyword("no-map"                         ,  0, KW_NO_MAP  , true ),
             new Keyword("no-message"                     ,  6, KW_NO_MSG  , true ),
             new Keyword("no-pause"                       ,  0, KW_NO_PAUSE, true ),
             new Keyword("no-prefetch"                    ,  8, KW_NO_PRE  , true ),
             new Keyword("no-row-markers"                 ,  0, KW_NO_ROW_M, false),
             new Keyword("no-return-value"                , 13, KW_NO_RET_V, true ),  // missing in keyword index, found elsewhere in external program interface ref
             new Keyword("no-schema-marshal"              ,  0, KW_NO_SCH_M, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("no-scrollbar-vertical"          ,  0, KW_NO_SCR_V, false),
             new Keyword("no-separators"                  ,  0, KW_NO_SEPS , false),
             new Keyword("no-separate-connection"         ,  0, KW_NO_SEP_C, false),
             new Keyword("no-tab-stop"                    ,  0, KW_NO_TAB_S, false),
             new Keyword("no-underline"                   ,  6, KW_NO_UNDL , false),
             new Keyword("no-undo"                        ,  0, KW_NO_UNDO , true ),
             new Keyword("no-validate"                    ,  6, KW_NO_VALID, true ),
             new Keyword("no-wait"                        ,  0, KW_NO_WAIT , true ),
             new Keyword("no-word-wrap"                   ,  0, KW_NO_WRAP , false),
             new Keyword("node-bold"                      ,  0, KW_NODE_BLD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-click"                     ,  0, KW_N_CLICK , false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-collapsed"                 ,  0, KW_N_COLED , false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-collapsing"                ,  0, KW_N_COLING, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-expanded"                  ,  0, KW_N_EXPED , false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-expanding"                 ,  0, KW_N_EXPING, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-check"                     ,  0, KW_NODE_CHE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-count"                     ,  0, KW_NODE_CNT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-expanded"                  ,  0, KW_NODE_EXP, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-height"                    ,  0, KW_N_HEIGHT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-icon"                      ,  0, KW_NODE_ICO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-id"                        ,  0, KW_NODE_ID , false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-index"                     ,  0, KW_NODE_IDX, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-key"                       ,  0, KW_NODE_KEY, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-key-to-id"                 ,  0, KW_N_KEY_ID, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-parent"                    ,  0, KW_NODE_PAR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-text"                      ,  0, KW_NODE_TXT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("node-value"                     ,  0, KW_NODE_VAL, false),
             new Keyword("node-value-to-memptr"           ,  0, KW_NODE_V2M, false),
             new Keyword("node-value-to-longchar"         ,  0, KW_NODV_2LC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("nodes"                          ,  0, KW_NODES,    false ),  // FWD extension, not a real 4GL keyword
             new Keyword("non-serializable"               ,  0, KW_NON_SER , false),  // missing in keyword index, found elsewhere in lang ref, UNTESTED
             new Keyword("nonamespace-schema-location"    ,  0, KW_NNMSP_SL, false),
             new Keyword("none"                           ,  0, KW_NONE    , false),
             new Keyword("normal"                         ,  3, KW_NORMAL  , false),
             new Keyword("normalize"                      ,  0, KW_NORMALZE, false),
             new Keyword("not"                            ,  0, KW_NOT     , true ),
             new Keyword("not-active"                     ,  0, KW_NOT_ACTV, false),
             new Keyword("now"                            ,  0, KW_NOW     , true ),
             new Keyword("null"                           ,  0, KW_NULL    , true ),
             new Keyword("num-aliases"                    ,  7, KW_NUM_ALIA, true ),
             new Keyword("num-buffers"                    ,  0, KW_NUM_BUFF, false),
             new Keyword("num-buttons"                    ,  7, KW_NUM_BUTT, false),
             new Keyword("num-children"                   ,  0, KW_NUM_CHLN, false),
             new Keyword("num-child-relations"            ,  0, KW_NUM_CH_R, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("num-copies"                     ,  0, KW_NUM_COPY, false),
             new Keyword("num-columns"                    ,  7, KW_NUM_COL , false),
             new Keyword("num-dbs"                        ,  0, KW_NUM_DBS , true ),
             new Keyword("num-dropped-files"              ,  0, KW_NUM_DROP, false),
             new Keyword("num-entries"                    ,  0, KW_NUM_ENT , true ),
             new Keyword("num-fields"                     ,  0, KW_NUM_FLD , false),
             new Keyword("num-formats"                    ,  0, KW_NUM_FMTS, false),
             new Keyword("num-header-entries"             ,  0, KW_NUM_HD_E, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("num-items"                      ,  0, KW_NUM_ITMS, false),
             new Keyword("num-iterations"                 ,  0, KW_NUM_ITER, false),
             new Keyword("num-lines"                      ,  0, KW_NUM_LNS , false),
             new Keyword("num-locked-columns"             , 14, KW_NUM_LK_C, false),
             new Keyword("num-log-files"                  ,  0, KW_NUM_LOGF, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("num-messages"                   ,  0, KW_NUM_MSG , false),
             new Keyword("num-parameters"                 ,  0, KW_NUM_PARM, false),
             new Keyword("num-references"                 ,  0, KW_NUM_REF , false),
             new Keyword("num-relations"                  ,  0, KW_NUM_REL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("num-replaced"                   ,  0, KW_NUM_REPL, false),
             new Keyword("num-results"                    ,  0, KW_NUM_RES , false),
             new Keyword("num-selected-rows"              ,  0, KW_NUM_SR  , false),
             new Keyword("num-selected-widgets"           , 12, KW_NUM_SW  , false),
             new Keyword("num-source-buffers"             ,  0, KW_NUM_SRCB, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("num-top-buffers"                ,  0, KW_NUM_TOPB, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("num-tabs"                       ,  0, KW_NUM_TABS, false),
             new Keyword("num-to-retain"                  ,  0, KW_NUM_2RTN, false),
             new Keyword("num-visible-columns"            ,  0, KW_NUM_V_C , false),
             new Keyword("numberoftabletpoints"           ,  0, KW_NUM_PNTS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("numeric"                        ,  0, KW_NUMERIC , false),
             new Keyword("numeric-decimal-point"          , 15, KW_NUM_D_P , false),
             new Keyword("numeric-format"                 ,  9, KW_NUM_FMT , false),
             new Keyword("numeric-separator"              ,  0, KW_NUM_SEP , false),
             new Keyword("object"                         ,  0, KW_OBJECT  , false),
             new Keyword("octet-length"                   ,  0, KW_OCT_LEN , false),
             new Keyword("ocx-mouse-button"               ,  0, KW_OCX_MBTN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("mouse-icon"                     ,  0, KW_MSICON,   false),  // FWD WidgetExtension extension, not a real 4GL keyword
             new Keyword("mouse-pointer-num"              ,  0, KW_MSPNTNUM, false),  // FWD WidgetExtension extension, not a real 4GL keyword
             new Keyword("ocx-mouse-shift"                ,  0, KW_OCX_MSHT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ocx-mouse-x"                    ,  0, KW_OCX_MSX , false),  // FWD extension, not a real 4GL keyword
             new Keyword("ocx-mouse-y"                    ,  0, KW_OCX_MSY , false),  // FWD extension, not a real 4GL keyword
             new Keyword("of"                             ,  0, KW_OF      , true ),
             new Keyword("off-end"                        ,  0, KW_OFF_END , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("off-home"                       ,  0, KW_OFF_HOME, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("off"                            ,  0, KW_OFF     , true ),
             new Keyword("ok"                             ,  0, KW_OK      , false),
             new Keyword("ok-cancel"                      ,  0, KW_OK_CAN  , false),
             new Keyword("old"                            ,  0, KW_OLD     , true ),
             new Keyword("ole-invoke-locale"              ,  0, KW_OLE_INVL, false),
             new Keyword("ole-names-locale"               ,  0, KW_OLE_NAML, false),
             new Keyword("ole-complete-drag"              ,  0, KW_OLE_CDRG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-drag-drop"                  ,  0, KW_OLE_DD  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-drag-over"                  ,  0, KW_OLE_DGOV, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-give-feedback"              ,  0, KW_OLE_GIVF, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-set-data"                   ,  0, KW_OLE_SETD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-start-drag"                 ,  0, KW_OLE_STDG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-allowed-effects"            ,  0, KW_OLE_AEFF, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-data-format"                ,  0, KW_OLE_DATF, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-drag"                       ,  0, KW_OLE_DRAG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-default-cursors"            ,  0, KW_OLE_DEFC, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-drag-mode"                  ,  0, KW_OLE_DGMD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-drop-mode"                  ,  0, KW_OLE_DRMD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-state"                      ,  0, KW_OLE_STAT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-x"                          ,  0, KW_OLE_X,    false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-y"                          ,  0, KW_OLE_Y,    false),  // FWD extension, not a real 4GL keyword
             new Keyword("ole-effect"                     ,  0, KW_OLE_EFFE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("dragged-node"                   ,  0, KW_DRAG_NOD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("dragged-over-node"              ,  0, KW_DRAG_OVR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("on"                             ,  0, KW_ON      , true ),
             new Keyword("on-frame-border"                ,  8, KW_ON_FR_B , false),
             new Keyword("only"                           ,  0, KW_ONLY    , false),
             new Keyword("open"                           ,  0, KW_OPEN    , true ),
             new Keyword("open-html-string"               ,  0, KW_OPENHTML, true ),  // FWD extension, not real 4GL!
             new Keyword("open-line-above"                ,  0, KW_OPEN_L_A, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("open-mime-resource"             ,  0, KW_OPENMIME, false),  // FWD extension, not real 4GL!
             new Keyword("open-popup"                     ,  0, KW_OPENPOPU, false),  // FWD extension, not real 4GL!
             new Keyword("open-web-page"                  ,  0, KW_OPENPAGE, true ),  // FWD extension, not real 4GL!
             new Keyword("open-url"                       ,  0, KW_OPEN_URL, false),  // FWD-extension, not real 4GL!
             new Keyword("opsys"                          ,  0, KW_OPSYS   , true ),
             new Keyword("option"                         ,  0, KW_OPTION  , true ),
             new Keyword("options"                        ,  0, KW_OPTIONS , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("options-file"                   ,  0, KW_OPTIONSF, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("or"                             ,  0, KW_OR      , true ),
             new Keyword("ordinal"                        ,  0, KW_ORDINAL , false),
             new Keyword("order"                          ,  0, KW_ORDER   , false),  // missing in keyword index, found in SQL reference
             new Keyword("ordered-join"                   ,  0, KW_ORD_JOIN, false),
             new Keyword("origin-handle"                  ,  0, KW_ORG_HAND, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("origin-rowid"                   ,  0, KW_ORG_ROID, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("os2"                            ,  0, KW_OS2     , true ),  // undocumented
             new Keyword("os-append"                      ,  0, KW_OS_APPND, true ),
             new Keyword("os-copy"                        ,  0, KW_OS_COPY , true ),
             new Keyword("os-command"                     ,  0, KW_OS_CMD  , true ),
             new Keyword("os-create-dir"                  ,  0, KW_OS_MKDIR, true ),
             new Keyword("os-drives"                      ,  8, KW_OS_DRV  , false),
             new Keyword("os-delete"                      ,  0, KW_OS_DEL  , true ),
             new Keyword("os-dir"                         ,  0, KW_OS_DIR  , true ),
             new Keyword("os-error"                       ,  0, KW_OS_ERR  , false),
             new Keyword("os-getenv"                      ,  0, KW_OS_G_ENV, false),
             new Keyword("os-rename"                      ,  0, KW_OS_REN  , true ),
             new Keyword("os-userid"                      ,  0, KW_OS_UID  , false),  // FWD-extension, not real 4GL!
             new Keyword("otherwise"                      ,  0, KW_OTHER   , true ),
             new Keyword("outer-join"                     ,  0, KW_OUT_JOIN, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("outer"                          ,  0, KW_OUTER   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("output"                         ,  0, KW_OUTPUT  , true ),
             new Keyword("outputcontenttype"              ,  0, KW_OUTPUTCT, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("output-content-type"            ,  0, KW_OUTPUTCT, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("outputheaders"                  ,  0, KW_OUT_HDR , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("outputheader"                   ,  0, KW_OUT_HDR , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("outputhttpheader"               ,  0, KW_OUT_HH  , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("output-http-header"             ,  0, KW_OUT_HH  , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("output-messages"                ,  0, KW_OUT_MSGS, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("overlay"                        ,  0, KW_OVERLAY , true ),
             new Keyword("override"                       ,  0, KW_OVERRIDE, false),
             new Keyword("owner"                          ,  0, KW_OWNER   , false),
             new Keyword("owner-document"                 ,  0, KW_OWN_DOC , false),
             new Keyword("p2j-remote-call"                ,  0, KW_P2J_RC  , false),  // P2J-extension, not real 4GL!
             new Keyword("package-private"                ,  0, KW_PK_PRIV, false),
             new Keyword("package-protected"              ,  0, KW_PK_PROT, false),
             new Keyword("page"                           ,  0, KW_PAGE    , true ),
             new Keyword("paged"                          ,  0, KW_PAGED   , false),
             new Keyword("page-bottom"                    ,  8, KW_PAGE_B  , true ),
             new Keyword("page-down"                      ,  0, KW_PAGE_DWN, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("page-left"                      ,  0, KW_PAGE_LFT, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("page-number"                    ,  8, KW_PAGE_NUM, true ),
             new Keyword("page-right"                     ,  0, KW_PAGE_RT , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("page-size"                      ,  0, KW_PAGE_SZ , false),
             new Keyword("page-top"                       ,  0, KW_PAGE_T  , true ),
             new Keyword("page-up"                        ,  0, KW_PAGE_UP , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("page-width"                     ,  8, KW_PAGE_WID, false),
             new Keyword("parameter"                      ,  5, KW_PARM    , true ),
             new Keyword("parent-buffer"                  ,  0, KW_PAR_BUFF, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("parent-fields-after"            ,  0, KW_PAR_FLDA, false),
             new Keyword("parent-fields-before"           ,  0, KW_PAR_FLDB, false),
             new Keyword("parent-id-field"                ,  0, KW_PAR_IFLD, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("parent-id-relation"             ,  0, KW_PAR_IREL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("parent-relation"                ,  0, KW_PAR_REL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("parent-window-close"            ,  0, KW_PAR_W_C , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("parent"                         ,  0, KW_PARENT  , false),
             new Keyword("parse-status"                   ,  0, KW_PARSE_ST, false),
             new Keyword("partial-key"                    ,  0, KW_PART_KEY, false),
             new Keyword("pathname"                       ,  0, KW_PATHNAME, false),
             new Keyword("pascal"                         ,  0, KW_PASCAL  , false),
             new Keyword("password-field"                 ,  0, KW_PASSWD_F, true ),
             new Keyword("paste"                          ,  0, KW_PASTE   , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("pause"                          ,  0, KW_PAUSE   , true ),
             new Keyword("pbe-hash-algorithm"             , 12, KW_PBE_H_AL, false),
             new Keyword("pbe-key-rounds"                 ,  0, KW_PBE_KEYR, false),
             new Keyword("pdbname"                        ,  0, KW_PDBNAME , true ),
             new Keyword("performance"                    ,  0, KW_PERF    , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("persistent"                     ,  7, KW_PERSIST , true ),
             new Keyword("persistent-procedure"           ,  0, KW_PRS_PROC, false),
             new Keyword("persistent-cache-disabled"      ,  0, KW_PRS_C_D , false),
             new Keyword("pfcolor"                        ,  3, KW_PFCOLOR , false),
             new Keyword("pick"                           ,  0, KW_PICK    , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("pick-area"                      ,  0, KW_PICK_ARE, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("pick-both"                      ,  0, KW_PICK_BTH, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("pixels"                         ,  0, KW_PIXELS  , true ),
             new Keyword("pixels-per-column"              , 14, KW_PIX_COL , false),
             new Keyword("pixels-per-row"                 ,  0, KW_PIX_ROW , false),
             new Keyword("portrait"                       ,  0, KW_PORTRAIT, false),
             new Keyword("position"                       ,  7, KW_POS     , false),
             new Keyword("post-message"                   ,  0, KW_POSTMSG , true ),  // FWD extension, not real 4GL!
             new Keyword("popup-menu"                     ,  7, KW_POP_MENU, false),
             new Keyword("popup-only"                     ,  7, KW_POP_ONLY, false),
             new Keyword("precision"                      ,  0, KW_PRECISN , false),
             new Keyword("prefer-dataset"                 ,  0, KW_PREF_DS , false),
             new Keyword("prepare-string"                 ,  0, KW_PREP_STR, false),
             new Keyword("prepared"                       ,  0, KW_PREPARED, false),
             new Keyword("preprocess"                     ,  7, KW_PREPROC , true ),
             new Keyword("preprocessed-label"             ,  0, KW_PRE_LBL , false), // FWD extension, not real 4GL!
             new Keyword("preselect"                      ,  6, KW_PRESEL  , false),
             new Keyword("prev"                           ,  0, KW_PREV    , false),
             new Keyword("prev-column"                    ,  0, KW_PREV_COL, false),
             new Keyword("prev-frame"                     ,  0, KW_PREV_FR , false),
             new Keyword("prev-sibling"                   ,  0, KW_PREV_SIB, false),
             new Keyword("prev-tab-item"                  , 10, KW_PREV_T_I, false),
             new Keyword("prev-word"                      ,  0, KW_PREVWORD, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("primary"                        ,  0, KW_PRIMARY , false),
             new Keyword("primary-passphrase"             ,  0, KW_PRIM_P_P, false), // PRIMARY-PASSPHRASE
             new Keyword("print"                          ,  0, KW_PRINT,    false),  // FWD extension, not real 4GL!
             new Keyword("printer"                        ,  0, KW_PRINTER , false),
             new Keyword("printer-control-handle"         ,  0, KW_PRT_C_H , false),
             new Keyword("printer-hdc"                    ,  0, KW_PRT_HDC , false),
             new Keyword("printer-name"                   ,  0, KW_PRT_NAME, false),
             new Keyword("printer-port"                   ,  0, KW_PRT_PORT, false),
             new Keyword("printer-setup"                  ,  0, KW_PRT_SET , false),
             new Keyword("private"                        ,  0, KW_PRIVATE , false),
             new Keyword("private-data"                   ,  9, KW_PRIV_DAT, false),
             new Keyword("privileges"                     ,  0, KW_PRIVILEG, true ),
             new Keyword("procedure-name"                 ,  0, KW_PROCNAME, false),
             new Keyword("procedure-call-type"            ,  0, KW_PROC_C_T, true ),
             new Keyword("procedure-complete"             ,  0, KW_PROC_COM, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("procedure-type"                 ,  0, KW_PROCTYPE, false),
             new Keyword("procedure"                      ,  5, KW_PROC    , false),
             new Keyword("process-architecture"           ,  0, KW_PRO_ARCH, false),  // this is not reserved, but attempting to declare a var with the same name will not be able to alter it at runtime (remains constant)
             new Keyword("process-web-request"            ,  0, KW_PROC_W_R, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("process"                        ,  0, KW_PROCESS , true ),
             new Keyword("proc-handle"                    ,  7, KW_PROC_HND, true ),
             new Keyword("proc-status"                    ,  7, KW_PROC_ST , true ),
             new Keyword("proc-text"                      ,  0, KW_PROC_TXT, false),
             new Keyword("proc-text-buffer"               ,  0, KW_PROC_T_B, false),
             new Keyword("prodataset"                     ,  0, KW_PRODATAS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("profiler"                       ,  0, KW_PROFILER, true ),
             new Keyword("profiling"                      ,  0, KW_PROFILNG, false),  // missing from keyword index, found in customer code and UNTESTED at this time
             new Keyword("program-name"                   ,  0, KW_PROGNAME, true ),
             new Keyword("progress"                       ,  0, KW_PROGRESS, true ),
             new Keyword("progress-bar"                   ,  0, KW_PROG_BAR, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-appearance"                  ,  0, KW_PB_APPEA, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-border-style"                ,  0, KW_PB_BRSTY, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-enabled"                     ,  0, KW_PB_ENABL, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-max"                         ,  0, KW_PB_MAX  , false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-min"                         ,  0, KW_PB_MIN  , false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-orientation"                 ,  0, KW_PB_ORIEN, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-scrolling"                   ,  0, KW_PB_SCROL, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("pb-value"                       ,  0, KW_PB_VALUE, false),  // FWD PROGRESS-BAR extension, not a real 4GL keyword
             new Keyword("progress-source"                , 10, KW_PROG_SRC, false),
             new Keyword("prompt"                         ,  0, KW_PROMPT  , true),   // keyword index lists this as unreserved, which is incorrect
             new Keyword("prompt-for"                     ,  8, KW_PRMT_FOR, true ),
             new Keyword("promsgs"                        ,  0, KW_PROMSGS , true ),
             new Keyword("propath"                        ,  0, KW_PROPATH , true ),
             new Keyword("property"                       ,  0, KW_PROPERTY, false),
             new Keyword("protected"                      ,  0, KW_PROTECTD, false),
             new Keyword("proversion"                     ,  7, KW_PROVER  , true ),
             new Keyword("proxy"                          ,  0, KW_PROXY   , false),
             new Keyword("proxy-password"                 ,  0, KW_PROX_PWD, false),
             new Keyword("proxy-userid"                   ,  0, KW_PROX_UID, false),
             new Keyword("public-id"                      ,  0, KW_PUB_ID  , false),
             new Keyword("public"                         ,  0, KW_PUBLIC  , false),
             new Keyword("publish"                        ,  0, KW_PUBLISH , true),   // keyword index lists this as unreserved, which is incorrect
             new Keyword("published-events"               ,  0, KW_PUB_EVTS, false),
             new Keyword("put"                            ,  0, KW_PUT     , true ),
             new Keyword("put-bits"                       ,  0, KW_PUT_BITS, false),
             new Keyword("putbyte"                        ,  0, KW_PUT_BYTE, true ),
             new Keyword("put-byte"                       ,  0, KW_PUT_BYTE, true ),
             new Keyword("put-int64"                      ,  0, KW_PUT_I64 , false),
             new Keyword("put-bytes"                      ,  0, KW_PUT_BYTS, false),
             new Keyword("put-double"                     ,  0, KW_PUT_DBL , false),
             new Keyword("put-float"                      ,  0, KW_PUT_FLT , false),
             new Keyword("put-key-value"                  , 11, KW_PUT_K_V , true ),
             new Keyword("put-long"                       ,  0, KW_PUT_LONG, false),
             new Keyword("put-short"                      ,  0, KW_PUT_SHT , false),
             new Keyword("put-string"                     ,  0, KW_PUT_STR , false),
             new Keyword("put-unsigned-long"              ,  0, KW_PUT_UL  , false),
             new Keyword("put-unsigned-short"             ,  0, KW_PUT_USHT, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("qualified-user-id"              ,  0, KW_QUAL_UID, false),
             new Keyword("query"                          ,  0, KW_QUERY   , true ),
             new Keyword("query-close"                    ,  0, KW_QRY_CLOS, true ),
             new Keyword("query-off-end"                  ,  0, KW_QRY_OFF , true ),
             new Keyword("query-open"                     ,  0, KW_QRY_OPEN, false),
             new Keyword("query-prepare"                  ,  0, KW_QRY_PREP, false),
             new Keyword("query-tuning"                   ,  0, KW_QRY_TUNE, true ),
             new Keyword("question"                       ,  0, KW_QUEST   , false),
             new Keyword("queue-message"                  ,  0, KW_QUE_MSG , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("quit"                           ,  0, KW_QUIT    , true ),
             new Keyword("quoter"                         ,  0, KW_QUOTER  , false),
             new Keyword("r-index"                        ,  0, KW_R_INDEX , true ),
             new Keyword("radio-buttons"                  ,  0, KW_RADIO_B , false),
             new Keyword("radio-set"                      ,  0, KW_RADIO_S , false),
             new Keyword("random"                         ,  0, KW_RANDOM  , false),
             new Keyword("raw"                            ,  0, KW_RAW     , false),
             new Keyword("raw-transfer"                   ,  0, KW_RAW_TRAN, false),
             new Keyword("rcode-information"              , 10, KW_RCOD_INF, true ),
             new Keyword("readkey"                        ,  0, KW_READKEY , true ),
             new Keyword("real"                           ,  0, KW_REAL    , false),
             new Keyword("read"                           ,  0, KW_READ    , false),
             new Keyword("read-available"                 ,  0, KW_READ_AVL, true ),
             new Keyword("read-exact-num"                 ,  0, KW_READ_E_N, true ),
             new Keyword("read-file"                      ,  0, KW_READ_FIL, false),
             new Keyword("read-json"                      ,  0, KW_READ_JSN, false),
             new Keyword("read-only"                      ,  0, KW_READ_ONL, false),
             new Keyword("read-response"                  ,  0, KW_READ_RES, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("read-xml"                       ,  0, KW_READ_XML, false),
             new Keyword("read-xmlschema"                 ,  0, KW_READ_XSC, false),
             new Keyword("recall"                         ,  0, KW_RECALL  , false),
             new Keyword("recid"                          ,  0, KW_RECID   , true ),
             new Keyword("record-length"                  ,  0, KW_REC_LEN , false),
             new Keyword("rectangle"                      ,  4, KW_RECT    , true ),
             new Keyword("recursive"                      ,  0, KW_RECURSE , false),
             new Keyword("reference-only"                 ,  0, KW_REF_ONLY, false),
             new Keyword("refresh"                        ,  0, KW_REFRESH , false),
             new Keyword("refresh-audit-policy"           ,  0, KW_REFR_A_P, false),
             new Keyword("refreshable"                    ,  0, KW_REFRABLE, false),
             new Keyword("refresh-ui"                     ,  0, KW_RFRSH_UI, false),  // FWD WidgetExtension extension, not a real 4GL keyword
             new Keyword("register"                       ,  0, KW_REGISTER, false),  // FWD extension, not a real 4GL keyword
             new Keyword("register-domain"                ,  0, KW_REG_DMN , false),
             new Keyword("reject-changes"                 ,  0, KW_REJ_CHGS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("reject-row-changes"             ,  0, KW_REJ_RCHG, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("rejected"                       ,  0, KW_REJECTED, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("related-session-id"             ,  0, KW_RELSESID, false),  // FWD extension, not a real 4GL keyword
             new Keyword("relation-fields"                ,  0, KW_REL_FLDS, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("relations-active"               ,  0, KW_RELS_ACT, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("release"                        ,  0, KW_RELEASE , true ),
             new Keyword("remote-host"                    ,  0, KW_REM_HOST, false),
             new Keyword("remote-port"                    ,  0, KW_REM_PORT, false),
             new Keyword("remote"                         ,  0, KW_REMOTE  , false),
             new Keyword("remove-attribute"               ,  0, KW_REM_ATTR, false),
             new Keyword("remove-child"                   ,  0, KW_REM_CHLD, false),
             new Keyword("remove-events-procedure"        ,  0, KW_REM_EVTP, false),
             new Keyword("remove-node"                    ,  0, KW_REM_NODE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("remove-node-on-collapse"        ,  0, KW_REM_NOCO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("remove-super-procedure"         ,  0, KW_REM_SUP , false),
             new Keyword("repeat"                         ,  0, KW_REPEAT  , true ),
             new Keyword("replace"                        ,  0, KW_REPLACE , false),
             new Keyword("replace-child"                  ,  0, KW_REP_CHLD, false),
             new Keyword("replace-selection-text"         ,  0, KW_REP_STXT, false),
             new Keyword("replication-create"             ,  0, KW_REPL_CRE, false),
             new Keyword("replication-delete"             ,  0, KW_REPL_DEL, false),
             new Keyword("replication-write"              ,  0, KW_REPL_WRI, false),
             new Keyword("report"                         ,  0, KW_REPORT  , false),  // FWD extension, not real 4GL; Jasper report
             new Keyword("report-data-source"             ,  0, KW_RPT_SRC , false),  // FWD extension, not real 4GL; query for Jasper report
             new Keyword("report-design"                  ,  0, KW_RPT_DSGN, false),  // FWD extension, not real 4GL; design file for Jasper report
             new Keyword("reports"                        ,  0, KW_REPORTS , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("reposition"                     ,  0, KW_REPOS   , true ),
             new Keyword("reposition-backwards"           , 19, KW_REPOS_B , true ),  // the documented keyword is reposition-backward with no abbrev, but customer code shows reposition-backwards as a valid alternative
             new Keyword("reposition-forwards"            , 18, KW_REPOS_F , true ),  // the documented keyword is reposition-forward with no abbrev, but customer code shows reposition-forwards as a valid alternative
             new Keyword("reposition-mode"                ,  0, KW_REPOS_M , false),
             new Keyword("reposition-to-row"              ,  0, KW_REPOS_2R, true ),
             new Keyword("reposition-to-rowid"            ,  0, KW_REPOS_2I, true ),
             new Keyword("request"                        ,  0, KW_REQUEST , false),
             new Keyword("request-info"                   ,  0, KW_REQ_INFO, false),
             new Keyword("resource-base"                  ,  0, KW_RES_BASE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("response-info"                  ,  0, KW_RSP_INFO, false),
             new Keyword("reset"                          ,  0, KW_RESET   , false),
             new Keyword("resize"                         ,  0, KW_RESIZE  , false),
             new Keyword("resizable"                      ,  6, KW_RESIZABL, false),
             new Keyword("resort"                         ,  0, KW_RESORT  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("restart-row"                    ,  0, KW_REST_ROW, false),
             new Keyword("restart-rowid"                  ,  0, KW_REST_RID, false),
             new Keyword("result"                         ,  0, KW_RESULT  , false),
             new Keyword("resume-display"                 ,  0, KW_RESUME_D, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("retain"                         ,  0, KW_RETAIN  , true ),
             new Keyword("retain-shape"                   ,  0, KW_RET_SHAP, false),
             new Keyword("retry"                          ,  0, KW_RETRY   , true ),
             new Keyword("retry-cancel"                   ,  0, KW_RETRY_C , false),
             new Keyword("return"                         ,  0, KW_RETURN  , true ),
             new Keyword("return-value-data-type"         ,  0, KW_RET_VDT , false),
             new Keyword("return-value-dll-type"          ,  0, KW_RET_VLT , false),
             new Keyword("returns"                        ,  0, KW_RETURNS , false),  // the Progress 4GL Reference incorrectly states this is reserved, but testing shows it is unreserved
             new Keyword("return-inserted"                , 10, KW_RET_INS , false),
             new Keyword("return-value"                   , 10, KW_RET_VAL , false),
             new Keyword("return-to-start-dir"            , 18, KW_RET_2SD , false),
             new Keyword("reverse-from"                   ,  0, KW_REV_FROM, false),
             new Keyword("revert"                         ,  0, KW_REVERT  , true ),
             new Keyword("revoke"                         ,  0, KW_REVOKE  , true ),
             new Keyword("rgb-value"                      ,  0, KW_RGB_VAL , false),
             new Keyword("right"                          ,  0, KW_RIGHT   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("right-aligned"                  , 11, KW_RIGHT_AL, false),
             new Keyword("right-end"                      ,  0, KW_RT_END  , false),  // missing from keyword index, found elsewhere in lang ref
             new Keyword("right-mouse-click"              ,  0, KW_RT_MC   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("right-mouse-dblclick"           ,  0, KW_RT_MDC  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("right-mouse-down"               ,  0, KW_RT_MD   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("right-mouse-up"                 ,  0, KW_RT_MU   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("rt-opsys"                       ,  0, KW_RTOPSYS , true ),  // FWD extension, not real 4GL!
             new Keyword("right-trim"                     ,  0, KW_R_TRIM  , false),
             new Keyword("role"                           ,  0, KW_ROLE    , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("roles"                          ,  0, KW_ROLES   , false),
             new Keyword("round"                          ,  0, KW_ROUND   , false),
             new Keyword("rounded"                        ,  0, KW_ROUNDED , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("routine-level"                  ,  0, KW_ROUTINEL, false),
             new Keyword("row"                            ,  0, KW_ROW     , false),
             new Keyword("row-create"                     ,  0, KW_ROW_CRT , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("row-created"                    ,  0, KW_ROW_CRTD, true ),  // missing from keyword index, found elsewhere in lang ref, TESTED
             new Keyword("row-delete"                     ,  0, KW_ROW_DEL , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("row-deleted"                    ,  0, KW_ROW_DELD, true ),  // missing from keyword index, found elsewhere in lang ref, TESTED
             new Keyword("row-display"                    ,  0, KW_ROW_DISP, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("row-entry"                      ,  0, KW_ROW_ENTR, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("row-height-chars"               , 10, KW_ROW_H_C , false),
             new Keyword("row-height-pixels"              , 12, KW_ROW_H_P , false),
             new Keyword("row-leave"                      ,  0, KW_ROW_LEAV, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("row-markers"                    ,  6, KW_ROW_MARK, false),  // the abbreviation here is undocumented, but found in customer source, TESTED
             new Keyword("row-modified"                   ,  0, KW_ROW_MODD, true ),  // missing from keyword index, found elsewhere in lang ref, TESTED
             new Keyword("row-resizable"                  ,  0, KW_ROW_RESZ, false),
             new Keyword("row-state"                      ,  0, KW_ROW_STAT, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("row-unmodified"                 ,  0, KW_ROW_UMOD, true ),  // missing from keyword index, found elsewhere in lang ref, TESTED
             new Keyword("row-update"                     ,  0, KW_ROW_UPD , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("rowid"                          ,  0, KW_ROWID   , false ), // documented as reserved in the keyword index, but found to be unreserved
             new Keyword("row-of"                         ,  0, KW_ROW_OF  , false),
             new Keyword("rule"                           ,  0, KW_RULE    , false),
             new Keyword("rule-row"                       ,  0, KW_RULE_ROW, false),
             new Keyword("rule-y"                         ,  0, KW_RULE_Y  , false),
             new Keyword("run-procedure"                  ,  0, KW_RUN_PROC, false),
             new Keyword("run-web-object"                 ,  0, KW_RUN_W_O , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("run"                            ,  0, KW_RUN     , true ),
             new Keyword("save"                           ,  0, KW_SAVE    , true ),
             new Keyword("save-as"                        ,  0, KW_SAVE_AS , false),
             new Keyword("save-file"                      ,  0, KW_SAVE_FIL, false),
             new Keyword("save-row-changes"               ,  0, KW_SAVE_RCH, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("save-where-string"              ,  0, KW_SAVE_WST, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("sax-attributes"                 ,  0, KW_SAX_ATTR, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("sax-complete"                   , 10, KW_SAX_COMP, true ),
             new Keyword("sax-parse"                      ,  0, KW_SAX_PARS, false),
             new Keyword("sax-parser-error"               ,  0, KW_SAX_PARE, true ),
             new Keyword("sax-parse-first"                ,  0, KW_SAX_PARF, false),
             new Keyword("sax-parse-next"                 ,  0, KW_SAX_PARN, false),
             new Keyword("sax-reader"                     ,  0, KW_SAX_READ, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("sax-running"                    ,  0, KW_SAX_RUNN, true ),
             new Keyword("sax-uninitialized"              ,  0, KW_SAX_UNIN, true ),
             new Keyword("sax-write-begin"                ,  0, KW_SAX_WBEG, true ),
             new Keyword("sax-write-complete"             ,  0, KW_SAX_WCOM, true ),
             new Keyword("sax-write-content"              ,  0, KW_SAX_WCON, true ),
             new Keyword("sax-write-element"              ,  0, KW_SAX_WELM, true ),
             new Keyword("sax-write-error"                ,  0, KW_SAX_WERR, true ),
             new Keyword("sax-write-idle"                 ,  0, KW_SAX_WIDL, true ),
             new Keyword("sax-write-tag"                  ,  0, KW_SAX_WTAG, true ),
             new Keyword("sax-writer"                     ,  0, KW_SAX_WRIT, false),
             new Keyword("schema"                         ,  0, KW_SCHEMA  , true ),
             new Keyword("schema-change"                  ,  0, KW_SCH_CHG , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("schema-location"                ,  0, KW_SCH_LOC , false),
             new Keyword("schema-marshal"                 ,  0, KW_SCH_MARS, false),
             new Keyword("schema-path"                    ,  0, KW_SCH_PATH, false),
             new Keyword("screen"                         ,  0, KW_SCREEN  , true ),
             new Keyword("screen-color-depth"             ,  0, KW_SCR_COL , false),  // FWD extension, not a real 4GL keyword
             new Keyword("screen-height"                  ,  0, KW_SCR_HGHT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("screen-io"                      ,  0, KW_SCRN_IO , true ),
             new Keyword("screen-lines"                   ,  0, KW_SCRN_LNS, true ),
             new Keyword("screen-scaling-factor"          ,  0, KW_SCR_SCAL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("screen-value"                   ,  9, KW_SCRN_VAL, true ),
             new Keyword("screen-width"                   ,  0, KW_SCR_WDTH, false),  // FWD extension, not a real 4GL keyword
             new Keyword("scroll"                         ,  0, KW_SCROLL  , true ),
             new Keyword("scroll-bars"                    ,  0, KW_SCROLLBA, false),
             new Keyword("scroll-delta"                   ,  0, KW_SCR_DELT, false),
             new Keyword("scroll-left"                    ,  0, KW_SCR_LEFT, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("scroll-mode"                    ,  0, KW_SCR_MODE, false),  // missing from keyword index, found elsewhere in lang ref
             new Keyword("scroll-node-count"              ,  0, KW_SCR_NODC, false ),  // FWD extension, not a real 4GL keyword
             new Keyword("scroll-node-to-top"             ,  0, KW_SCR_NTOP, false),  // FWD extension, not a real 4GL keyword
             new Keyword("scroll-notify"                  ,  0, KW_SCR_NOT , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("scroll-offset"                  ,  0, KW_SCR_OFFS, false),
             new Keyword("scroll-right"                   ,  0, KW_SCR_RT  , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("scroll-to-current-row"          ,  0, KW_SCR_2CR , false),
             new Keyword("scroll-to-item"                 , 11, KW_SCR_2ITM, false),
             new Keyword("scroll-to-selected-row"         ,  0, KW_SCR_2SR , false),
             new Keyword("scroll-vertical"                ,  0, KW_SCR_VERT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("scroll-wheel-lines"             ,  0, KW_SCR_WLNS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("scrollable"                     ,  0, KW_SCROLLBL, false),
             new Keyword("scrollbar-horizontal"           , 11, KW_SCROLL_H, false),
             new Keyword("scrollbar-vertical"             , 11, KW_SCROLL_V, false),
             new Keyword("scrolled-row-position"          , 16, KW_SCR_RPOS, false),
             new Keyword("scrolling"                      ,  0, KW_SCROLLIN, false),
             new Keyword("sdbname"                        ,  0, KW_SDBNAME , true ),
             new Keyword("seal"                           ,  0, KW_SEAL    , false),
             new Keyword("seal-timestamp"                 ,  0, KW_SEAL_TST, false),
             new Keyword("search"                         ,  0, KW_SEARCH  , true ),
             new Keyword("search-self"                    ,  0, KW_SEAR_SLF, true ),
             new Keyword("search-target"                  ,  0, KW_SEAR_TRG, true ),
             new Keyword("section"                        ,  0, KW_SECTION , false),
             new Keyword("security-policy"                ,  0, KW_SECUR_P , true ),
             new Keyword("seek"                           ,  0, KW_SEEK    , true ),
             new Keyword("select"                         ,  0, KW_SELECT  , true ),
             new Keyword("select-all"                     ,  0, KW_SEL_ALL , false),
             new Keyword("select-first-visible-node"      ,  0, KW_SEL_SFVN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("select-focused-row"             ,  0, KW_SEL_FOCR, false),
             new Keyword("select-next-row"                ,  0, KW_SEL_NEXT, false),
             new Keyword("select-prev-row"                ,  0, KW_SEL_PREV, false),
             new Keyword("select-row"                     ,  0, KW_SEL_ROW , false),
             new Keyword("selectable"                     ,  0, KW_SELECTBL, false),
             new Keyword("selected"                       ,  0, KW_SELECTED, false),
             new Keyword("selected-node"                  ,  0, KW_SEL_NODE, false),  // FWD extension, not a real 4GL keyword
             new Keyword("selected-node-id"               ,  0, KW_SEL_NID,  false),  // FWD extension, not a real 4GL keyword
             new Keyword("selected-node-key"              ,  0, KW_SEL_NKEY, false),  // FWD extension, not a real 4GL keyword
             new Keyword("selection"                      ,  0, KW_SELECTN , false),
             new Keyword("selection-end"                  ,  0, KW_SEL_END , false),
             new Keyword("selection-list"                 ,  0, KW_SEL_LST , false),
             new Keyword("selection-start"                ,  0, KW_SEL_STRT, false),
             new Keyword("selection-text"                 ,  0, KW_SEL_TXT , false),
             new Keyword("self"                           ,  0, KW_SELF    , true ),
             new Keyword("send"                           ,  0, KW_SEND    , false),
             new Keyword("send-sql-statement"             ,  8, KW_SEND_SQL, false),
             new Keyword("sensitive"                      ,  0, KW_SENSITIV, false),
             new Keyword("separate-connection"            ,  0, KW_SEP_CONN, false),
             new Keyword("separator-fgcolor"              ,  0, KW_SEP_FGC , false),
             new Keyword("separators"                     ,  0, KW_SEPS    , false),
             new Keyword("serializable"                   ,  0, KW_SERIALAB, false),
             new Keyword("serialize-hidden"               ,  0, KW_SERIALZH, false),
             new Keyword("serialize-name"                 ,  0, KW_SERIALZN, false),
             new Keyword("serialize-row"                  ,  0, KW_SERIALZR, false), // missing in keyword index, found elsewhere in lang ref, UNTESTED
             new Keyword("server"                         ,  0, KW_SERVER  , false),
             new Keyword("server-connection-bound"        ,  0, KW_SRV_C_B , false),
             new Keyword("server-connection-bound-request",  0, KW_SRV_C_BR, false),
             new Keyword("server-connection-context"      , 20, KW_SRV_C_C , false),  // the 4GL docs state that there is no abbreviation, but customer code proves that abbrevations down to 20 characters are possible
             new Keyword("server-connection-id"           ,  0, KW_SRV_C_I , false),
             new Keyword("server-operating-mode"          ,  0, KW_SRV_OP_M, false),
             new Keyword("server-socket"                  ,  0, KW_SRV_SOCK, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("session"                        ,  0, KW_SESSION , true ),
             new Keyword("session-end"                    ,  0, KW_SESS_END, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("session-id"                     ,  0, KW_SESSN_ID, false),
             new Keyword("set"                            ,  0, KW_SET     , true ),
             new Keyword("setimagefileformat"             ,  0, KW_SET_IMGF, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setimagepenwidth"               ,  0, KW_SET_PENW, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setimagexsize"                  ,  0, KW_SET_IMGH, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setimageysize"                  ,  0, KW_SET_IMGW, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setjustifymode"                 ,  0, KW_SET_JMOD, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setjustifyx"                    ,  0, KW_SET_JSTX, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setjustifyy"                    ,  0, KW_SET_JSTY, false),  // FWD extension, not a real 4GL keyword
             new Keyword("settings"                       ,  0, KW_SETTINGS, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("setlcdcapturemode"              ,  0, KW_SET_CPTM, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setsigwindow"                   ,  0, KW_SET_SWIN, false),  // FWD extension, not a real 4GL keyword
             new Keyword("settabletstate"                 ,  0, KW_SET_TSTA, false),  // FWD extension, not a real 4GL keyword
             new Keyword("settranslatebitmapenable"       ,  0, KW_SET_TBME, false),  // FWD extension, not a real 4GL keyword
             new Keyword("setuserid"                      ,  7, KW_SETUSER , true ),
             new Keyword("set-actor"                      ,  0, KW_SET_ACTR, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("set-appl-context"               ,  0, KW_SET_ACTX, false),
             new Keyword("set-attr-call-type"             ,  0, KW_SET_A_CT, true ),
             new Keyword("set-attribute"                  ,  0, KW_SET_ATTR, false),
             new Keyword("set-attribute-list"             ,  0, KW_SET_A_L , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("set-attribute-node"             ,  0, KW_SET_A_N , false),
             new Keyword("set-blue-value"                 ,  8, KW_SET_BLUE, false),
             new Keyword("set-break"                      ,  0, KW_SET_BRK , false),
             new Keyword("set-buffers"                    ,  0, KW_SET_BUF , false),
             new Keyword("set-byte-order"                 ,  0, KW_SET_B_OR, false),
             new Keyword("set-callback"                   ,  0, KW_SET_CBAC, false),
             new Keyword("set-callback-procedure"         ,  0, KW_SET_CB_P, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("set-cell-bgcolor"               ,  0, KW_S_C_BGCO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-cell-fgcolor"               ,  0, KW_S_C_FGCO, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-cell-icon"                  ,  0, KW_SET_C_IC, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-cell-string"                ,  0, KW_SET_C_S , false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-client"                     ,  0, KW_SET_CLNT, false),
             new Keyword("set-column-caption"             ,  0, KW_S_COL_C , false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-column-visible"             ,  0, KW_SET_C_VI, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-column-width"               ,  0, KW_S_COL_W , false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-commit"                     ,  0, KW_SET_COMM, false),
             new Keyword("set-connect-procedure"          ,  0, KW_SET_C_P , false),
             new Keyword("set-contents"                   ,  0, KW_SET_CONT, false),
             new Keyword("setcookie"                      ,  0, KW_SET_COOK, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("set-cookie"                     ,  0, KW_SET_COOK, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("set-db-client"                  ,  0, KW_SET_DBCL, false),
             new Keyword("set-dynamic"                    ,  0, KW_SET_DYN , false),
             new Keyword("set-event-manager-option"       ,  0, KW_SET_EVMO, false),
             new Keyword("set-font-details"               ,  0, KW_SET_F_D , false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-green-value"                ,  9, KW_SET_GRN , false),
             new Keyword("set-input-source"               ,  0, KW_SET_ISRC, false),
             new Keyword("set-lastkey"                    ,  0, KW_SET_LSTK, false),  // missing from keyword index, undocumented keyword found in customer code, confirmed as unreserved with no abbreviaton through testing
             new Keyword("set-must-understand"            ,  0, KW_SET_M_UN, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("set-multi-select"               ,  0, KW_SET_MSEL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-node"                       ,  0, KW_SET_NODE, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("set-node-bgcolor"               ,  0, KW_SET_N_BG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-node-fgcolor"               ,  0, KW_SET_N_FG, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-node-has-children"          ,  0, KW_SET_N_HC, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-node-text"                  ,  0, KW_SET_NTXT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-numeric-format"             ,  0, KW_SET_N_F , false),
             new Keyword("set-option"                     ,  0, KW_SET_OPT , false),
             new Keyword("set-output-destination"         ,  0, KW_SET_ODST, false),
             new Keyword("set-parameter"                  ,  0, KW_SET_PARM, false),
             new Keyword("set-property"                   ,  0, KW_SET_PROP, false),
             new Keyword("set-pointer-value"              ,  0, KW_SET_PTR , false),
             new Keyword("set-read-response-procedure"    ,  0, KW_SET_RRP , false),
             new Keyword("set-red-value"                  ,  7, KW_SET_RED , false),
             new Keyword("set-report-param"               ,  0, KW_SET_R_P , false),  // FWD extension, not real 4GL; set parameter for Jasper report
             new Keyword("set-repositioned-row"           ,  0, KW_SET_RPOS, false),
             new Keyword("set-rgb-value"                  ,  0, KW_SET_RGB , false),
             new Keyword("set-rollback"                   ,  0, KW_SET_ROLL, false),
             new Keyword("set-selected-node-colors"       ,  0, KW_SET_SNC , false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-selection"                  ,  0, KW_SET_SEL , false),
             new Keyword("set-serialized"                 ,  0, KW_SET_SERD, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("set-size"                       ,  0, KW_SET_SZ  , false),
             new Keyword("set-socket-option"              ,  0, KW_SET_S_O , false),
             new Keyword("set-sort-arrow"                 ,  0, KW_SET_S_AR, false),
             new Keyword("set-transaction-state"          ,  0, KW_SET_T_S , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("set-tree-node-icons"            ,  0, KW_SET_TN_I, false),  // FWD extension, not a real 4GL keyword
             new Keyword("set-user-field"                 ,  0, KW_SET_U_F , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("set-wait-state"                 ,  8, KW_SET_WAIT, false),  // undocumented abbreviation found in customer source
             new Keyword("set-working-directory"          ,  0, KW_SET_WKDR, false),  // FWD extension, not real 4GL!
             new Keyword("setwebstate"                    ,  0, KW_SET_W_S , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("sha1-digest"                    ,  0, KW_SHA1_DIG, false),
             new Keyword("share-lock"                     ,  5, KW_SH_LOCK , true ),
             new Keyword("shared"                         ,  0, KW_SHARED  , true ),
             new Keyword("short"                          ,  0, KW_SHORT   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("short-date-format"              ,  0, KW_SHR_D_F , false),  // FWD extension, not a real 4GL keyword
             new Keyword("show-buttons"                   ,  0, KW_SHOW_BUT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("show-header"                    ,  0, KW_SHOW_HDR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("show-in-taskbar"                ,  0, KW_SHOW_ITB, false),
             new Keyword("show-stats"                     ,  9, KW_SHOW_ST , true ),
             new Keyword("side-labels"                    ,  8, KW_SIDE_L  , false),
             new Keyword("side-label-handle"              , 12, KW_SIDE_L_H, false),
             new Keyword("signature"                      ,  0, KW_SIGNATUR, false),
             new Keyword("silent"                         ,  0, KW_SILENT  , false),
             new Keyword("simple"                         ,  0, KW_SIMPLE  , false),
             new Keyword("single"                         ,  0, KW_SINGLE  , false),
             new Keyword("single-run"                     ,  0, KW_SING_RUN, true),
             new Keyword("singleton"                      ,  0, KW_SINGLTON, false),
             new Keyword("size"                           ,  0, KW_SIZE    , false),
             new Keyword("size-chars"                     ,  6, KW_SIZE_C  , false),
             new Keyword("size-pixels"                    ,  6, KW_SIZE_P  , false),
             new Keyword("skip"                           ,  0, KW_SKIP    , true ),
             new Keyword("skip-deleted-record"            ,  0, KW_SKIP_D_R, true ),
             new Keyword("slider"                         ,  0, KW_SLIDER  , false),
             new Keyword("small-icon"                     ,  0, KW_SMAL_ICO, false),
             new Keyword("small-title"                    ,  0, KW_SMAL_TTL, false),
             new Keyword("smallint"                       ,  0, KW_SMALLINT, false),
             new Keyword("smtp-email"                     ,  0, KW_SMTP_EML, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-from"                      ,  0, KW_SMTPFROM, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-host"                      ,  0, KW_SMTPHOST, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-html"                      ,  0, KW_SMTPHTML, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-port"                      ,  0, KW_SMTPPORT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-reply-to"                  ,  0, KW_SMTPREPL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-subject"                   ,  0, KW_SMTPSUBJ, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-text"                      ,  0, KW_SMTPTEXT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-user"                      ,  0, KW_SMTPUSER, false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-password"                  ,  0, KW_SMTP_PW,  false),  // FWD extension, not a real 4GL keyword
             new Keyword("smtp-validate"                  ,  0, KW_SMTP_VAL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("soap-header"                    ,  0, KW_SOAP_HDR, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-header-entryref"           ,  0, KW_SOAP_HER, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault"                     ,  0, KW_SOAP_F  , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-actor"               ,  0, KW_SOAP_F_A, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-code"                ,  0, KW_SOAP_F_C, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-detail"              ,  0, KW_SOAP_F_D, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-misunderstood-header",  0, KW_SOAP_FMH, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-node"                ,  0, KW_SOAP_F_N, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-role"                ,  0, KW_SOAP_F_R, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-string"              ,  0, KW_SOAP_F_S, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-fault-subcode"             ,  0, KW_SOAP_FSC, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("soap-version"                   ,  0, KW_SOAP_VER, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("socket"                         ,  0, KW_SOCKET  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("some"                           ,  0, KW_SOME    , true ),
             new Keyword("sort"                           ,  0, KW_SORT    , false),
             new Keyword("sort-ascending"                 ,  0, KW_SORT_ASC, false),
             new Keyword("sort-number"                    ,  0, KW_SORT_NUM, false),
             new Keyword("sorted-column-count"            ,  0, KW_SOR_C_C , false),  // FWD extension, not a real 4GL keyword
             new Keyword("sorted-columns"                 ,  0, KW_SOR_COLS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("source"                         ,  0, KW_SOURCE  , false),
             new Keyword("source-procedure"               ,  0, KW_SRC_PROC, false),
             new Keyword("space"                          ,  0, KW_SPACE   , true ),
             new Keyword("spreadsheet"                    ,  0, KW_SPRSHEET, false),  // FWD extension, not a real 4GL keyword
             new Keyword("sql"                            ,  0, KW_SQL     , false),
             new Keyword("sqrt"                           ,  0, KW_SQRT    , false),
             new Keyword("ssl-server-name"                ,  0, KW_SSL_SRVN, false),
             new Keyword("standalone"                     ,  0, KW_STANDALN, false),
             new Keyword("start"                          ,  0, KW_START   , false),
             new Keyword("start-box-selection"            ,  0, KW_START_BS, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("start-move"                     ,  0, KW_START_MV, false),
             new Keyword("start-document"                 ,  0, KW_START_DC, false),
             new Keyword("start-element"                  ,  0, KW_START_EL, false),
             new Keyword("start-resize"                   ,  0, KW_START_RS, false),
             new Keyword("start-row-resize"               ,  0, KW_START_RR, false),
             new Keyword("start-search"                   ,  0, KW_START_SC, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("starting"                       ,  0, KW_STARTING, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("startup-parameters"             ,  0, KW_STUP_PAR, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("state-detail"                   ,  0, KW_STAT_DET, false),
             new Keyword("static"                         ,  0, KW_STATIC  , false),
             new Keyword("status"                         ,  0, KW_STATUS  , true ),
             new Keyword("status-area"                    ,  0, KW_STATUS_A, false),
             new Keyword("status-area-font"               ,  0, KW_STAT_A_F, false),
             new Keyword("stdcall"                        ,  0, KW_STDCALL , false),
             new Keyword("stop"                           ,  0, KW_STOP    , false),
             new Keyword("stop-after"                     ,  0, KW_STOP_AFT, true),
             new Keyword("stop-display"                   ,  0, KW_STOP_D  , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("stop-parsing"                   ,  0, KW_STOP_PRS, false),
             new Keyword("stopped"                        ,  6, KW_STOPPED , false),
             new Keyword("stored-procedure"               , 11, KW_STORPROC, false),
             new Keyword("stream"                         ,  0, KW_STREAM  , true ),
             new Keyword("stream-handle"                  ,  0, KW_STRM_HND, true ),
             new Keyword("stream-io"                      ,  0, KW_STRM_IO , true ),
             new Keyword("stretch-to-fit"                 ,  0, KW_ST_2_FIT, false),
             new Keyword("strict"                         ,  0, KW_STRICT  , false),
             new Keyword("strict-entity-resolution"       ,  0, KW_STRIC_ER, false),
             new Keyword("string-value"                   ,  0, KW_STR_VAL , false),
             new Keyword("string-xref"                    ,  0, KW_STR_XREF, false),
             new Keyword("string"                         ,  0, KW_STRING  , false),
             new Keyword("sub-average"                    ,  7, KW_SUB_AVG , false),
             new Keyword("sub-count"                      ,  0, KW_SUB_CNT , false),
             new Keyword("sub-maximum"                    ,  7, KW_SUB_MAX , false),
             new Keyword("sub-menu"                       ,  4, KW_SUB_MENU, false),
             new Keyword("sub-menu-help"                  ,  0, KW_SUB_M_H , false),
             new Keyword("sub-minimum"                    ,  7, KW_SUB_MIN , false),
             new Keyword("sub-total"                      ,  0, KW_SUB_TOT , false),
             new Keyword("subscribe"                      ,  0, KW_SUBSCRIB, true),   // keyword index lists this as unreserved, which is incorrect
             new Keyword("subtype"                        ,  0, KW_SUBTYPE , false),
             new Keyword("sum"                            ,  0, KW_SUM     , false),
             new Keyword("substitute"                     ,  5, KW_SUBSTIT , false),
             new Keyword("substring"                      ,  6, KW_SUBSTR  , false),
             new Keyword("super"                          ,  0, KW_SUPER   , true ),  // not documented as reserved, but in practice it is treated as such
             new Keyword("super-procedures"               , 10, KW_SUP_PROC, false),  // not documented to have abbreviations but found to abbreviate via customer code
             new Keyword("suppress-namespace-processing"  ,  0, KW_SUP_NS_P, false),
             new Keyword("suppress-warnings"              , 10, KW_SUP_WARN, false),
             new Keyword("suppress-warnings-list"         ,  0, KW_SUPW_LST, false),
             new Keyword("symmetric-encryption-algorithm" ,  0, KW_SYM_EN_A, false),
             new Keyword("symmetric-encryption-iv"        ,  0, KW_SYM_EN_I, false),
             new Keyword("symmetric-encryption-key"       ,  0, KW_SYM_EN_K, false),
             new Keyword("symmetric-support"              ,  0, KW_SYM_SUPP, false),
             new Keyword("synchronize"                    ,  0, KW_SYNCHRON, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("system-alert-boxes"             , 12, KW_SYS_A_B , false),
             new Keyword("system-dialog"                  ,  0, KW_SYS_DLG , true ),
             new Keyword("system-help"                    ,  0, KW_SYS_HELP, false),
             new Keyword("system-id"                      ,  0, KW_SYS_ID  , false),
             new Keyword("tab"                            ,  0, KW_TAB     , false),
             new Keyword("tabletmodelnumber"              ,  0, KW_TAB_MOD,  false),  // FWD extension, not a real 4GL keyword
             new Keyword("tabs"                           ,  0, KW_TABS    , false),  // FWD extension, not a real 4GL keyword
             new Keyword("tabs-show"                      ,  0, KW_TAB_SHOW, false),  // FWD extension, not a real 4GL keyword
             new Keyword("tab-index"                      ,  0, KW_TAB_IDX , false),  // FWD extension, not a real 4GL keyword
             new Keyword("tab-position"                   ,  0, KW_TAB_POS , false),
             new Keyword("tab-stop"                       ,  0, KW_TAB_STOP, false),
             new Keyword("table"                          ,  0, KW_TABLE   , true ),
             new Keyword("table-crc-list"                 ,  0, KW_TAB_CRCL, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("table-list"                     ,  0, KW_TAB_LIST, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("table-handle"                   ,  0, KW_TAB_HAND, false),
             new Keyword("table-number"                   ,  0, KW_TAB_NUM , true ),
             new Keyword("table-scan"                     ,  0, KW_TAB_SCAN, false),
             new Keyword("tabset"                         ,  0, KW_TABSET  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("tag"                            ,  0, KW_TAG     , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("target"                         ,  0, KW_TARGET  , false),
             new Keyword("target-procedure"               ,  0, KW_TAR_PROC, false),
             new Keyword("temp-directory"                 ,  8, KW_TEMP_DIR, false),
             new Keyword("temp-table"                     ,  0, KW_TEMP_TAB, false),
             new Keyword("temp-table-prepare"             ,  0, KW_TT_PREP , false),
             new Keyword("tenant-id"                      ,  0, KW_TEN_ID,   false),  // missing in keyword index, found in customer code
             new Keyword("tenant-name"                    ,  0, KW_TENNAME,  false),  // missing in keyword index, found in customer code
             new Keyword("tenant-name-to-id"              ,  0, KW_TN_TOID,  false),  // missing in keyword index, found in customer code
             new Keyword("term"                           ,  0, KW_TERM    , true ),  // non-abbreviated synonym for TERMINAL
             new Keyword("terminal"                       ,  0, KW_TERM    , true ),  // the keyword index incorrectly states that TERMINAL can be abbreviatated down to a minimum TERM, this is not correct, there is no abbreviation possible (just the synonym TERM)
             new Keyword("terminate"                      ,  0, KW_TERMINAT, false),
             new Keyword("termination-hook"               ,  0, KW_TERM_HK , false),  // FWD extension, not a real 4GL keyword
             new Keyword("text"                           ,  0, KW_TEXT    , true ),
             new Keyword("text-cursor"                    ,  0, KW_TXT_CURS, true ),
             new Keyword("text-seg-grow"                  ,  0, KW_TXT_SEG , false),
             new Keyword("text-selected"                  ,  0, KW_TXT_SEL , false),
             new Keyword("text-edit"                      ,  0, KW_TEXTEDIT, false ),  // FWD extension, not a real 4GL keyword
             new Keyword("then"                           ,  0, KW_THEN    , true ),
             new Keyword("this-object"                    ,  0, KW_THIS_OBJ, true ),
             new Keyword("this-procedure"                 ,  0, KW_THIS_PRC, true ),
             new Keyword("thousand-separator"             ,  0, KW_THO_SEP , false),  // FWD extension, not a real 4GL keyword
             new Keyword("thread-safe"                    ,  0, KW_THR_SAFE, false),
             new Keyword("three-d"                        ,  0, KW_3D      , false),
             new Keyword("thru"                           ,  0, KW_THROUGH , false),
             new Keyword("through"                        ,  0, KW_THROUGH , false),
             new Keyword("throw"                          ,  0, KW_THROW   , false),
             new Keyword("tic-marks"                      ,  0, KW_TIC_MARK, false),
             new Keyword("time"                           ,  0, KW_TIME    , true ),
             new Keyword("timer"                          ,  0, KW_TIMER   , false),  // FWD TIMER extension
             new Keyword("timezone"                       ,  0, KW_TIMEZONE, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("time-source"                    ,  0, KW_TIME_SRC, false),
             new Keyword("title"                          ,  0, KW_TITLE   , true ),
             new Keyword("title-bgcolor"                  ,  9, KW_TITL_BGC, false),
             new Keyword("title-dcolor"                   ,  8, KW_TITL_DC , false),
             new Keyword("title-fgcolor"                  ,  9, KW_TITL_FGC, false),
             new Keyword("title-font"                     ,  8, KW_TITL_FON, false),
             new Keyword("to"                             ,  0, KW_TO      , true ),
             new Keyword("today"                          ,  0, KW_TODAY   , false),
             new Keyword("toggle-box"                     ,  0, KW_TOGGL_BX, false),
             new Keyword("tooltip"                        ,  0, KW_TOOLTIP , false),
             new Keyword("tooltips"                       ,  0, KW_TOOLTIPS, false),
             new Keyword("top"                            ,  0, KW_TOP     , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("top-column"                     ,  0, KW_TOP_COL , false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("top-nav-query"                  ,  0, KW_TOP_NAVQ, false),
             new Keyword("top-only"                       ,  0, KW_TOP_ONLY, true ),
             new Keyword("topic"                          ,  0, KW_TOPIC   , false),
             new Keyword("total"                          ,  0, KW_TOTAL   , false),
             new Keyword("to-rowid"                       ,  0, KW_TO_ROWID, true ),
             new Keyword("trace-filter"                   ,  0, KW_TRC_FILT, false),  // missing from keyword index, found in customer code and UNTESTED at this time
             new Keyword("tracing"                        ,  0, KW_TRACING,  false),  // missing in keyword index, found in customer code
             new Keyword("tracking-changes"               ,  0, KW_TRAC_CHG, false),
             new Keyword("trailing"                       ,  0, KW_TRAILING, false),
             new Keyword("trans-init-procedure"           ,  0, KW_TRAN_I_P, false),
             new Keyword("trans"                          ,  0, KW_TRANS   , true ), // undocumented feature transa and transac are unreserved (just symbols) so we exclude them here by using 2 keyword defs to leave a loophole like in the 4GL
             new Keyword("transaction"                    ,  8, KW_TRANS   , true ),
             new Keyword("transaction-mode"               ,  0, KW_TRAN_MOD, false),
             new Keyword("transparent"                    ,  0, KW_TRANSPAR, false),
             new Keyword("tree-node-value"                ,  0, KW_TNOD_VAL, false),  // FWD extension, not a real 4GL keyword
             new Keyword("tree-row-height"                ,  0, KW_TREE_R_H, false),  // FWD extension, not a real 4GL keyword
             new Keyword("treelist"                       ,  0, KW_TREELIST, false),  // FWD extension, not a real 4GL keyword
             new Keyword("treeview"                       ,  0, KW_TREEVIEW, false),  // FWD extension, not a real 4GL keyword
             new Keyword("trigger"                        ,  0, KW_TRIGGER , true ),
             new Keyword("trigger-node"                   ,  0, KW_TRIG_NOD, true ),  // FWD extension, not a real 4GL keyword
             new Keyword("trigger-column"                 ,  0, KW_TRIG_COL, true ),  // FWD extension, not a real 4GL keyword
             new Keyword("triggers"                       ,  0, KW_TRIGGERS, true ),
             new Keyword("trim"                           ,  0, KW_TRIM    , true ),
             new Keyword("truncate"                       ,  5, KW_TRUNC   , false),
             new Keyword("true"                           ,  0, BOOL_TRUE  , true ),
             new Keyword("ttcodepage"                     ,  0, KW_TTCP    , false),  // missing from keyword index and UNTESTED at this time
             new Keyword("type"                           ,  0, KW_TYPE    , false),
             new Keyword("type-of"                        ,  0, KW_TYPE_OF , false),
             new Keyword("titlebackcolor"                 ,  0, KW_CALTITBG, false),  // CALENDAR:TitleBackColor
             new Keyword("titleforecolor"                 ,  0, KW_CALTITFG, false),  // CALENDAR:TitleForeColor
             new Keyword("trailingforecolor"              ,  0, KW_CALTRLFG, false),  // CALENDAR:TrailingForeColor
             new Keyword("unbox"                          ,  6, KW_UNBOX   , false),
             new Keyword("unbuffered"                     ,  6, KW_UNBUF   , false),
             new Keyword("undo"                           ,  0, KW_UNDO    , true ),
             new Keyword("undo-throw-scope"               ,  0, KW_UNDO_T_S, false ), // missing from keyword index and UNTESTED at this time
             new Keyword("unique"                         ,  0, KW_UNIQUE  , true ),
             new Keyword("unix"                           ,  0, KW_UNIX    , true ),
             new Keyword("unix-end"                       ,  0, KW_UNIX_END, false),  // missing in keyword index, found in prog handbook as a key function
             new Keyword("unless-hidden"                  ,  0, KW_UNL_HID , false),
             new Keyword("unload"                         ,  0, KW_UNLOAD  , false),
             new Keyword("underline"                      ,  6, KW_UNDERLIN, true ),
             new Keyword("unformatted"                    ,  6, KW_UNFORMAT, true ),
             new Keyword("union"                          ,  0, KW_UNION   , true ),
             new Keyword("unique-id"                      ,  0, KW_UNIQ_ID , false),
             new Keyword("unique-key"                     ,  0, KW_UNIQ_KEY, false),  // FWD extension, not a real 4GL keyword. Unique browse key.
             new Keyword("unique-match"                   ,  0, KW_UNIQ_MAT, false),
             new Keyword("unsigned-byte"                  ,  0, KW_UNS_BYTE, false),  // missing in keyword index, found elsewhere in external program interface ref
             new Keyword("unsigned-short"                 ,  0, KW_UNS_SHRT, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("unsigned-long"                  ,  0, KW_UNS_LONG, false),
             new Keyword("unsubscribe"                    ,  0, KW_UNSUBSCR, true),   // keyword index lists this as unreserved, which is incorrect
             new Keyword("up"                             ,  0, KW_UP      , true ),
             new Keyword("update"                         ,  0, KW_UPDATE  , true ),
             new Keyword("update-attribute"               ,  0, KW_UPD_ATTR, false),
             new Keyword("updown"                         ,  0, KW_CALUPDWN, false),  // FWD extension, CALENDAR:UpDown, not a real 4GL keyword
             new Keyword("upload"                         ,  0, KW_UPLOAD  , false),  // FWD extension, not a real 4GL keyword
             new Keyword("url"                            ,  0, KW_URL     , false),
             new Keyword("urldecode"                      ,  0, KW_URL_DECO, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("url-decode"                     ,  0, KW_URL_DECO, false),
             new Keyword("urlencode"                      ,  0, KW_URL_ENCO, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("url-encode"                     ,  0, KW_URL_ENCO, false),
             new Keyword("url-field"                      ,  0, KW_URL_FLD , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("url-field-list"                 ,  0, KW_URL_FLDL, false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("url-format"                     ,  0, KW_URL_FMT , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("url-password"                   ,  0, KW_URL_PW  , false),
             new Keyword("url-userid"                     ,  0, KW_URL_UID , false),
             new Keyword("user"                           ,  0, KW_USERID  , true ),
             new Keyword("userid"                         ,  0, KW_USERID  , true ),
             new Keyword("user-id"                        ,  0, KW_USER_ID , false),
             new Keyword("user-data"                      ,  0, KW_USR_DATA, false),  // missing in keyword reference, found in customer code
             new Keyword("use"                            ,  0, KW_USE     , false),
             new Keyword("use-dict-exps"                  ,  0, KW_USE_DCT , false),
             new Keyword("use-filename"                   ,  0, KW_USE_FIL , false),
             new Keyword("use-index"                      ,  0, KW_USE_IDX , true ),
             new Keyword("use-revvideo"                   ,  0, KW_USE_REV , false),
             new Keyword("use-text"                       ,  0, KW_USE_TXT , false),
             new Keyword("use-underline"                  ,  0, KW_USE_UND , false),
             new Keyword("use-widget-pool"                ,  0, KW_USE_WIDP, false),
             new Keyword("user-agent"                     ,  0, KW_BR_AGENT, false),  // FWD extension, not a real 4GL keyword
             new Keyword("using"                          ,  0, KW_USING   , true ),
             new Keyword("utc-offset"                     ,  0, KW_UTC_OFF , false),
             new Keyword("v-scroll-position"              ,  0, KW_V_SCRL_P, false),  // FWD extension, not a real 4GL keyword
             new Keyword("v6display"                      ,  0, KW_V6DISP  , false),
             new Keyword("v6frame"                        ,  0, KW_V6FRAME , true ),
             new Keyword("validate-expression"            ,  0, KW_VAL_EXPR, false),
             new Keyword("validate-message"               ,  0, KW_VAL_MSG , false),
             new Keyword("validate-seal"                  ,  0, KW_VAL_SEAL, false),
             new Keyword("validate-xml"                   ,  0, KW_VAL_XML , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("validate"                       ,  0, KW_VALIDATE, false),
             new Keyword("validation-enabled"             ,  0, KW_VAL_ENAB, false),
             new Keyword("valid-event"                    ,  0, KW_VAL_EVT , false),
             new Keyword("valid-handle"                   ,  0, KW_VAL_HND , false),
             new Keyword("valid-object"                   ,  0, KW_VAL_OBJ , false),
             new Keyword("value"                          ,  0, KW_VALUE   , true ),
             new Keyword("value-changed"                  ,  0, KW_VAL_CHG , true ),
             new Keyword("values"                         ,  0, KW_VALUES  , true ),
             new Keyword("variable"                       ,  3, KW_VAR     , false),
             new Keyword("verbose"                        ,  0, KW_VERBOSE , false),
             new Keyword("vertical"                       ,  4, KW_VERT    , false),
             new Keyword("version"                        ,  0, KW_VERSION , false),
             new Keyword("view"                           ,  0, KW_VIEW    , true ),
             new Keyword("view-as"                        ,  0, KW_VIEW_AS , true ),
             new Keyword("view-first-column-on-reopen"    ,  0, KW_VIEW_FCR, false),
             new Keyword("visible"                        ,  0, KW_VISIBLE , false),
             new Keyword("visible-node-count"             ,  0, KW_V_N_CNT , false),  // FWD extension, not a real 4GL keyword
             new Keyword("visible-row-count"              ,  0, KW_V_R_CNT , false),  // FWD extension, not a real 4GL keyword
             new Keyword("virtual-height-chars"           , 14, KW_VIRT_HC , false),
             new Keyword("virtual-height-pixels"          , 16, KW_VIRT_HP , false),
             new Keyword("virtual-width-chars"            , 13, KW_VIRT_WC , false),
             new Keyword("virtual-width-pixels"           , 15, KW_VIRT_WP , false),
             new Keyword("vms"                            ,  0, KW_VMS     , true ),  // undocumented
             new Keyword("void"                           ,  0, KW_VOID    , false),
             new Keyword("wait"                           ,  0, KW_WAIT    , false),  // non-abbreviated synonym for WAIT-FOR
             new Keyword("wait-for"                       ,  0, KW_WAIT_FOR, true ),
             new Keyword("warning"                        ,  0, KW_WARN    , false),
             new Keyword("wc-admin-app"                   ,  0, KW_WC_AD_AP, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("web"                            ,  0, KW_WEB     , false),  // missing in keyword index, found in WebSpeed reference
             new Keyword("web-context"                    ,  0, KW_WEB_CTX , false),
             new Keyword("web-file-upload"                ,  0, KW_WEB_FUP , false),  // FWD extension, not a real 4GL keyword
             new Keyword("web-upload-error"               ,  0, KW_WUPL_ERR, false),  // FWD extension, not a real 4GL keyword
             new Keyword("web-upload-files"               ,  0, KW_WUPL_FLS, false),  // FWD extension, not a real 4GL keyword
             new Keyword("web.output"                     ,  0, KW_WEB_OUT , false),  // not a real keyword, but is normally defined in the PSC webspeed 4GL code
             new Keyword("weekday"                        ,  0, KW_WEEK    , false),
             new Keyword("when"                           ,  0, KW_WHEN    , true ),
             new Keyword("where"                          ,  0, KW_WHERE   , true ),
             new Keyword("where-string"                   ,  0, KW_WHERE_ST, false),  // missing from keyword index and UNTESTED at this time
             new Keyword("while"                          ,  0, KW_WHILE   , true ),
             new Keyword("widget"                         ,  0, KW_WIDGET  , false),
             new Keyword("widget-enter"                   ,  8, KW_WID_ENT , false),
             new Keyword("widget-handle"                  ,  8, KW_WID_HAND, false),
             new Keyword("widget-id"                      ,  0, KW_WID_ID  , false),
             new Keyword("widget-leave"                   ,  8, KW_WID_LEAV, false),
             new Keyword("widget-pool"                    ,  0, KW_WID_POOL, false),
             new Keyword("width"                          ,  0, KW_WIDTH   , false),
             new Keyword("width-chars"                    ,  6, KW_WIDTH_C , false),
             new Keyword("width-pixels"                   ,  7, KW_WIDTH_P , false),
             new Keyword("window"                         ,  0, KW_WINDOW  , true ),
             new Keyword("window-close"                   ,  0, KW_WIN_CLOS, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("window-delayed-minimize"        , 17, KW_WIN_DMIN, true ),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("window-maximized"               , 12, KW_WIN_MAX , true ),
             new Keyword("window-minimized"               , 12, KW_WIN_MIN , true ),
             new Keyword("window-name"                    ,  0, KW_WIN_NAME, false),
             new Keyword("window-normal"                  ,  0, KW_WIN_NORM, true ),
             new Keyword("window-resized"                 ,  0, KW_WIN_RESI, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("window-restored"                ,  0, KW_WIN_REST, false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("window-state"                   , 10, KW_WIN_STAT, false),
             new Keyword("window-system"                  ,  0, KW_WIN_SYS , false),
             new Keyword("with"                           ,  0, KW_WITH    , true ),
             new Keyword("word-index"                     ,  0, KW_WORD_IDX, false),
             new Keyword("word-wrap"                      ,  0, KW_WORD_WRP, false),
             new Keyword("work-area-height-pixels"        ,  0, KW_WA_H_P  , false),
             new Keyword("work-area-width-pixels"         ,  0, KW_WA_W_P  , false),
             new Keyword("work-area-x"                    ,  0, KW_WA_X    , false),
             new Keyword("work-area-y"                    ,  0, KW_WA_Y    , false),
             new Keyword("workfile"                       ,  0, KW_WORK_TAB, true ),
             new Keyword("work-table"                     ,  8, KW_WORK_TAB, true ),
             new Keyword("write"                          ,  0, KW_WRITE   , true ),
             new Keyword("write-cdata"                    ,  0, KW_WR_CDATA, false),
             new Keyword("write-characters"               ,  0, KW_WR_CHARS, false),
             new Keyword("write-comment"                  ,  0, KW_WR_CMNT , false),
             new Keyword("write-data"                     ,  0, KW_WR_DATA,  false),  // missing in keyword reference, found in customer code
             new Keyword("write-data-element"             ,  0, KW_WR_D_ELM, false),
             new Keyword("write-empty-element"            ,  0, KW_WR_E_ELM, false),
             new Keyword("write-entity-ref"               ,  0, KW_WR_ENT_R, false),
             new Keyword("write-external-dtd"             ,  0, KW_WR_EXDTD, false),
             new Keyword("write-fragment"                 ,  0, KW_WR_FRAGM, false),
             new Keyword("write-json"                     ,  0, KW_WR_JSON , false),
             new Keyword("write-message"                  ,  0, KW_WR_MSG  , false),
             new Keyword("write-processing-instruction"   ,  0, KW_WR_PRINS, false),
             new Keyword("write-status"                   ,  0, KW_WR_STAT , false),
             new Keyword("write-xml"                      ,  0, KW_WR_XML  , false),
             new Keyword("write-xmlschema"                ,  0, KW_WR_XMLSC, false),
             new Keyword("x"                              ,  0, KW_X       , false),
             new Keyword("xcode"                          ,  0, KW_XCODE   , true ),
             new Keyword("xml-data-type"                  ,  0, KW_XML_DTYP, false),
             new Keyword("xml-entity-expansion-limit"     ,  0, KW_XML_E_EL, false),
             new Keyword("xml-node-name"                  ,  0, KW_XML_NNAM, false),  // missing in keyword index, found elsewhere in lang ref, TESTED
             new Keyword("xml-node-type"                  ,  0, KW_XML_NTYP, false),
             new Keyword("xml-schema-path"                ,  0, KW_XML_SCHP, false),
             new Keyword("xml-strict-entity-resolution"   ,  0, KW_XML_S_ER, false),
             new Keyword("xml-suppress-namespace-processing",0, KW_XML_SNSP, false),
             new Keyword("xpr-to-pdf"                     ,  0, KW_XPR2PDF , false),  // FWD extension, not real 4GL!
             new Keyword("xor"                            ,  0, KW_XOR     , true ),  // missing in keyword index, found elsewhere in lang ref, tested to confirm it is reserved
             new Keyword("xref"                           ,  0, KW_XREF    , true ),
             new Keyword("xref-xml"                       ,  0, KW_XREF_XML, true ),
             new Keyword("x-document"                     ,  0, KW_X_DOC   , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("x-noderef"                      ,  0, KW_X_NODE  , false),  // missing in keyword index, found elsewhere in lang ref
             new Keyword("x-of"                           ,  0, KW_X_OF    , false),
             new Keyword("year"                           ,  0, KW_YEAR    , false),
             new Keyword("year-offset"                    ,  0, KW_YEAR_OFF, false),
             new Keyword("yes"                            ,  0, BOOL_TRUE  , true ),
             new Keyword("yes-no"                         ,  0, KW_YES_NO  , false),
             new Keyword("yes-no-cancel"                  ,  0, KW_YES_NO_C, false),
             new Keyword("y"                              ,  0, KW_Y       , false),
             new Keyword("y-of"                           ,  0, KW_Y_OF    , false)
          };
       }

       /**
        * Constructs a lexer using a reader as input and associating a
        * <code>SymbolResolver</code> with the instance. The reader will be
        * wrapped in a {@link DotKludgeReader} instance.
        *
        * @param    in
        *           The reader representing the Progress 4GL source code.
        * @param    sr
        *           Provides keyword dictionary storage and lookup for symbol
        *           resolution in the lexer.
        */
       public ProgressLexer(Reader in, SymbolResolver sr)
       {
          this(in, sr, true);
       }

       /**
        * Constructs a lexer using a reader as input and associating a
        * <code>SymbolResolver</code> with the instance.
        *
        * @param    in
        *           The reader representing the Progress 4GL source code.
        * @param    sr
        *           Provides keyword dictionary storage and lookup for symbol
        *           resolution in the lexer.
        * @param    kludge
        *           <code>true</code> to force the reader to be wrapped in a
        *           {@link DotKludgeReader} instance.
        */
       public ProgressLexer(Reader in, SymbolResolver sr, boolean kludge)
       {
          this(new CharBuffer(kludge ? new DotKludgeReader(in) : in));
          sym = sr;
          initializeKeywordDictionary();
          readCfg();
       }

       /**
        * Constructs a lexer using stream as input and associating a
        * <code>SymbolResolver</code> with the instance.  The stream will be
        * wrapped in a {@link DotKludgeStream} instance.
        *
        * @param    in
        *           The stream representing the Progress 4GL source code.
        * @param    sr
        *           Provides keyword dictionary storage and lookup for symbol
        *           resolution in the lexer.
        */
       public ProgressLexer(InputStream in, SymbolResolver sr)
       {
          this(in, sr, true);
       }

       /**
        * Constructs a lexer using stream as input and associating a
        * <code>SymbolResolver</code> with the instance.
        *
        * @param    in
        *           The stream representing the Progress 4GL source code.
        * @param    sr
        *           Provides keyword dictionary storage and lookup for symbol
        *           resolution in the lexer.
        * @param    kludge
        *           <code>true</code> to force the stream to be wrapped in a
        *           {@link DotKludgeStream} instance.
        */
       public ProgressLexer(InputStream in, SymbolResolver sr, boolean kludge)
       {
          this(new ByteBuffer(kludge ? new DotKludgeStream(in) : in));
          sym = sr;
          initializeKeywordDictionary();
          readCfg();
       }

       /**
        * Initialize configuration values.
        */
       public void readCfg()
       {
          allowSlashSlash = Configuration.getParameter("allow-slash-slash", true);
          unixEscapes = Configuration.getParameter("unix-escapes", true);
       }

       /**
        * Get the keyword list.
        *
        * @return   The list of all recognized keywords.
        */
       public static Keyword[] getKeywords()
       {
          return keywords;
       }

       /**
        * Get the keyword ignore list.
        *
        * @return   The list of all ignored keywords.
        */
       public static Keyword[] getIgnoredKeywords()
       {
          return ignored;
       }

       /**
        * Remove each of the given keywords from the keyword dictionary. This
        * matches the behavior of the Progress "keyword forget" list (the -k
        * parameter on startup).
        *
        * @param   names
        *          Keywords to remove.
        */
       public void ignoreKeywords(String[] names)
       {
          ArrayList<Keyword> list = new ArrayList<Keyword>();

          for (int i = 0; i < names.length; i++)
          {
             Keyword found = sym.lookupKeyword(names[i]);

             if (found != null)
             {
                list.add(found);
                sym.removeKeyword(found);
             }
             else
             {
                String err = String.format("Cannot ignore unknown keyword '%s'.",
                                           names[i]);

                // TODO: log this?
                System.out.println(err);
             }
          }

          if (!list.isEmpty())
          {
             ignored = list.toArray(new Keyword[0]);
          }
       }

       /**
        * Reports on the state of debug in the lexer.
        *
        * @return    Debug state.
        */
       public boolean isDebug()
       {
          return debug;
       }

       /**
        * Sets the state of debug in the lexer.
        *
        * @param    dbg
        *           Debug state.
        */
       public void setDebug( boolean dbg )
       {
          debug = dbg;
       }

       /**
        * Reports on whether schema-specific processing is activated in the lexer.
        *
        * @return    Schema-specific processing activation state.
        */
       public boolean isSchema()
       {
          return schema;
       }

       /**
        * Activates schema-specific processing in the lexer.  At this time the
        * only difference in output is in the recognized keywords.  This is a
        * 'one way' state change and cannot be reversed!
        */
       public void activateSchemaProcessing()
       {
          schema = true;
          initializeSchemaKeywords();
       }

       /**
        * Reports on whether export-specific processing is activated in the lexer.
        *
        * @return    Export-specific processing activation state.
        */
       public boolean isExport()
       {
          return export;
       }

       /**
        * Activates export-specific processing in the lexer.  This is used
        * specifically by semantic predicate logic in the lexer DSTRING rule
        * to handle export mode-specific processing which differs from the
        * standard string rules.  This is a 'one way' state change and cannot
        * be reversed!
        */
       public void activateExportMode()
       {
          export = true;
       }

       /**
        * Reports on whether hidden stream processing is activated in the lexer.
        *
        * @return    Hidden stream processing activation state.
        */
       public boolean isHidden()
       {
          return hidden;
       }

       /**
        * Activates hidden stream processing in the lexer. This sets the returned
        * token class to <code>TokenStreamHiddenTokenFilter</code> and disables
        * the lexer's normal 'skip' processing of certain token types.
        * This is a 'one way' state change and cannot be reversed!
        */
       public void activateHiddenProcessing()
       {
          hidden = true;
          setTokenObjectClass("com.goldencode.ast.ManagedHiddenStreamToken");
       }

       /**
        * Turns on/off raw string processing mode.  The mode may be changed an
        * arbitrary number of times.
        *
        * @param     raw
        *            Raw processing mode:  <code>true</code> to turn on,
        *            <code>false</code> to turn off.
        */
       public void setRaw(boolean raw)
       {
          this.raw = raw;
       }

       /**
        * Reports on whether the lexer is currently in raw string processing
        * mode.
        *
        * @return    <code>true</code> if in raw string mode, else
        *            <code>false</code>.
        */
       public boolean isRaw()
       {
          return raw;
       }

       /**
        * Sets whether the lexer is currently honoring the backslash as
        * an escape character.
        *
        * @param     unixEscapes
        *            <code>true</code> if in UNIX escape mode, else
        *            <code>false</code>.
        */
       public void setUnixEscapes(boolean unixEscapes)
       {
          this.unixEscapes = unixEscapes;
       }

       /**
        * Reports on whether the lexer is currently honoring the backslash as
        * an escape character.
        *
        * @return    <code>true</code> if in UNIX escape mode, else
        *            <code>false</code>.
        */
       public boolean isUnixEscapes()
       {
          return unixEscapes;
       }

       /**
        * Allow this instance to cleanup any resources that were allocated.
        */
       public void close()
       {
          // nothing to do
       }

       /**
        * Process the keyword array to add each <code>Keyword</code> into the
        * keyword dictionary. This method is called during construction so that
        * all lexer processing can have keyword lookup facilities available
        * from the first token.  The keyword array is a static member initialized
        * during class load.
        */
       private void initializeKeywordDictionary()
       {
          if (sym.isRuntimeConfig())
          {
             // already initialized from an exemplar
             return;
          }
          for (int i = 0; i < keywords.length; i++)
          {
             sym.addKeyword(keywords[i]);
          }
       }

       /**
        * Creates a <code>Keyword</code> array and initializes that array to
        * a the list of all Progress schema-specific keywords. The
        * initialization is done in-line and the source file is organized in
        * an easy to maintain column format.  A loop then processes this array
        * and adds each <code>Keyword</code> into the keyword dictionary. This
        * method is called during construction so that all lexer processing can
        * have keyword lookup facilities available from the first token.
        * <p>
        * The following values are needed for each <code>Keyword</code> object:
        * <ul>
        *    <li> full keyword text for the keyword
        *    <li> the minimum number of characters for matching (abbreviations
        *         will always be disabled so this value is set to 0)
        *    <li> the integer token type to assign to the keyword on a match
        *         (see below)
        *    <li> whether it is a reserved keyword or not (these keywords are
        *         never reserved so this value is always <code>false</code>)
        * </ul>
        * <p>
        * See <code>{@link Keyword}</code> for more details.
        * <p>
        * The core idea here is to populate a facility where the symbol text (in
        * the mSYMBOL method) can be submitted to the keyword dictionary for a
        * lookup. If a match is found, then the token type of the token is set
        * based on the token type field in the <code>Keyword</code> object
        * found in the dictionary.  This returned token type will override the
        * default token type of <code>SYMBOL</code>.  Since all of these keywords
        * are not encoded in the matching rules of the grammar itself, there are
        * no actual token definitions in the lexer that match these keywords.
        * For this reason, we take advantage of the feature in the parser in
        * which we can create (reserve) a unique integer value and associate it
        * with a specific artificial token name (e.g. KW_DEFINE).  These
        * artificial token types are used as the values when constructing
        * <code>Keyword</code> objects.
        * <p>
        * When adding <code>Keyword</code> objects to this array, make sure to
        * add the associated artificial token type to the tokens { } section
        * of the parser.
        */
       private void initializeSchemaKeywords()
       {
          Keyword[] schemaKeywords =
          {
             /* format:  Full Keyword Text   , Abr, Token Type     , Reserved */
             new Keyword("abbreviated"       ,   0, KW_ABBV        , false),
             new Keyword("area"              ,   0, KW_AREA        , false),
             new Keyword("bigint"            ,   0, KW_BIGINT      , false),
             new Keyword("buffer-pool"       ,   0, KW_BUFRPOOL    , false),
             new Keyword("bufpool"           ,   0, KW_BUFPOOL     , false),
             new Keyword("category"          ,   0, KW_CATEGORY    , false),
             new Keyword("clob-codepage"     ,   0, KW_CLOB_CP     , false),
             new Keyword("clob-collation"    ,   0, KW_CLOB_COL    , false),
             new Keyword("clob-type"         ,   0, KW_CLOB_TYP    , false),
             new Keyword("column-label-sa"   ,   0, KW_COL_L_SA    , false),
             new Keyword("crc"               ,   0, KW_CRC         , false),
             new Keyword("cycle-on-limit"    ,   0, KW_CYCLE       , false),
             new Keyword("dump-name"         ,   0, KW_DMP_NAME    , false),
             new Keyword("field-trigger"     ,   0, KW_FLD_TRG     , false),
             new Keyword("fixchar"           ,   0, KW_FIXCHAR     , false),
             new Keyword("format-sa"         ,   0, KW_FMT_SA      , false),
             new Keyword("frozen"            ,   0, KW_FROZEN      , false),
             new Keyword("help-sa"           ,   0, KW_HELP_SA     , false),
             new Keyword("index-field"       ,   0, KW_IDX_FLD     , false),
             new Keyword("inactive"          ,   0, KW_INACTIVE    , false),
             new Keyword("increment"         ,   0, KW_INCR        , false),
             new Keyword("initial-sa"        ,   0, KW_INIT_SA     , false),
             new Keyword("label-sa"          ,   0, KW_LABEL_SA    , false),
             new Keyword("lob-area"          ,   0, KW_LOB_AREA    , false),
             new Keyword("lob-bytes"         ,   0, KW_LOB_BYTE    , false),
             new Keyword("lob-size"          ,   0, KW_LOB_SIZE    , false),
             new Keyword("multitenant"       ,   0, KW_MULTI_TN    , false),
             new Keyword("no-default-area"   ,   0, KW_NO_DEFAR    , false),
             new Keyword("no-override"       ,   0, KW_NO_OVRRD    , false),
             new Keyword("not-case-sensitive",   0, KW_NOT_CS      , false),
             new Keyword("null-allowed"      ,   0, KW_NULLALWD    , false),
             new Keyword("psc"               ,   0, KW_PSC         , false),
             new Keyword("sequence"          ,   0, KW_SEQUENCE    , false),
             new Keyword("sql-width"         ,   0, KW_SQL_WID     , false),
             new Keyword("table-trigger"     ,   0, KW_TAB_TRG     , false),
             new Keyword("timestamp"         ,   0, KW_TIMESTMP    , false),
             new Keyword("word"              ,   0, KW_WORD_IDX    , false),
             new Keyword("valexp"            ,   0, KW_VALEXP      , false),
             new Keyword("valmsg"            ,   0, KW_VALMSG      , false),
             new Keyword("valmsg-sa"         ,   0, KW_VALMG_SA    , false)
          };

          for (int i = 0; i < schemaKeywords.length; i++)
          {
             sym.addKeyword(schemaKeywords[i]);
          }
       }

       /**
        * Provides a command line interface for an end user to drive and/or test
        * the ProgressLexer class.
        * <p>
        * Syntax:
        * <pre>
        *    java ProgressLexer &lt;Progress_4GL_source_file&gt;
        * </pre>
        * Where:
        * <ul>
        *   <li> &lt;Progress_4GL_source_filename&gt; is the filename of a
        *        preprocessed Progress 4GL source file (enclose the name in
        *        double quotes if spaces or other reserved command line
        *        characters are part of the filename)
        * </ul>
        *
        * @param   args
        *          List of command line arguments.
        */
       public static void main(String[] args)
       {
          String syntax = "Syntax: java ProgressLexer <Progress_4GL_source_file>";

          if (args.length != 1)
          {
             LOG.log(Level.SEVERE, syntax);
             System.exit(-1);
          }

          try
          {
             // setup
             SymbolResolver    sym    = new SymbolResolver(true);
             FileReader        fr     = new FileReader(args[0]);
             BufferedReader    br     = new BufferedReader(fr);
             LexerDumpFilter   test   = new LexerDumpFilter(br, sym);

             test.setOutput(new PrintWriter(System.out));
             test.activateHiddenProcessing();
             test.setBypassSkip(true);

             // start the lexing and print a record for each token
             test.dump();
          }

          catch (Exception excpt)
          {
             LOG.log(Level.SEVERE, "", excpt);
          }
       }
    public ProgressLexer(InputStream in) {
    	this(new ByteBuffer(in));
    }
    public ProgressLexer(Reader in) {
    	this(new CharBuffer(in));
    }
    public ProgressLexer(InputBuffer ib) {
    	this(new LexerSharedInputState(ib));
    }
    public ProgressLexer(LexerSharedInputState state) {
    	super(state);
    	caseSensitiveLiterals = false;
    	setCaseSensitive(false);
    	literals = new Hashtable();
    }

    public Token nextToken() throws TokenStreamException {
    	Token theRetToken=null;
    tryAgain:
    	for (;;) {
    		Token _token = null;
    		int _ttype = Token.INVALID_TYPE;
    		resetText();
    		try {   // for char stream error handling
    			try {   // for lexical error handling
    				switch ( LA(1)) {
    				case '\u0000':  case '\u0001':  case '\u0002':  case '\u0003':
    				case '\u0004':  case '\u0005':  case '\u0006':  case '\u0007':
    				case '\u0008':  case '\t':  case '\n':  case '\u000b':
    				case '\u000c':  case '\r':  case '\u000e':  case '\u000f':
    				case '\u0010':  case '\u0011':  case '\u0012':  case '\u0013':
    				case '\u0014':  case '\u0015':  case '\u0016':  case '\u0017':
    				case '\u0018':  case '\u0019':  case '\u001a':  case '\u001b':
    				case '\u001c':  case '\u001d':  case '\u001e':  case '\u001f':
    				case ' ':  case '\u007f':
    				{
    					mWS(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '~':
    				{
    					mTILDE(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '"':  case '\'':
    				{
    					mSTRING(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case ',':
    				{
    					mCOMMA(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '=':
    				{
    					mEQUALS(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '(':
    				{
    					mLPARENS(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case ')':
    				{
    					mRPARENS(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '[':
    				{
    					mLBRACKET(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case ']':
    				{
    					mRBRACKET(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '@':
    				{
    					mAT(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '^':
    				{
    					mCARET(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				case '?':
    				{
    					mUNKNOWN_VAL(true);
    					theRetToken=_returnToken;
    					break;
    				}
    				default:
    					if ((LA(1)=='/') && (LA(2)=='*')) {
    						mCOMMENT(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)==':') && (LA(2)==':')) {
    						mDB_REF_NON_STATIC(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='*') && (LA(2)=='=')) {
    						mMULT_ASSIGN(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='+') && (LA(2)=='=')) {
    						mPLUS_ASSIGN(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='-') && (LA(2)=='=')) {
    						mMINUS_ASSIGN(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='/') && (LA(2)=='=')) {
    						mDIV_ASSIGN(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='<') && (LA(2)=='>')) {
    						mNOT_EQ(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='>') && (LA(2)=='=')) {
    						mGTE(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='<') && (LA(2)=='=')) {
    						mLTE(true);
    						theRetToken=_returnToken;
    					}
    					else if ((_tokenSet_0.member(LA(1))) && (true)) {
    						mSYMBOL(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)==':') && (true)) {
    						mCOLON(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='>') && (true)) {
    						mGT(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='<') && (true)) {
    						mLT(true);
    						theRetToken=_returnToken;
    					}
    					else if ((LA(1)=='*') && (true)) {
    						mMULTIPLY(true);
    						theRetToken=_returnToken;
    					}
    					else if ((_tokenSet_1.member(LA(1))) && (true)) {
    						mNUM_LITERAL(true);
    						theRetToken=_returnToken;
    					}
    					else if ((_tokenSet_2.member(LA(1)))) {
    						mUNKNOWN_TOKEN(true);
    						theRetToken=_returnToken;
    					}
    				else {
    					if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
    				else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}
    				}
    				if ( _returnToken==null ) continue tryAgain; // found SKIP token
    				_ttype = _returnToken.getType();
    				_returnToken.setType(_ttype);
    				return _returnToken;
    			}
    			catch (RecognitionException e) {
    				throw new TokenStreamRecognitionException(e);
    			}
    		}
    		catch (CharStreamException cse) {
    			if ( cse instanceof CharStreamIOException ) {
    				throw new TokenStreamIOException(((CharStreamIOException)cse).io);
    			}
    			else {
    				throw new TokenStreamException(cse.getMessage());
    			}
    		}
    	}
    }

    /**
     * Matches any amount of whitespace in a program and sets the token type to
     * &quot;skip&quot;.  In addition, each newline character causes the lexer's
     * line counter to be incremented in order to properly maintain each token's
     * line information.
     * <p>
     * Spaces, tabs and carriage returns and line feeds (newlines) are all
     * matched.  Although the preprocessor generally removes carriage returns,
     * if the input file was to include a ~015 (escaped carriage return), it
     * would be placed in the output file.  For safety, we must leave the
     * carriage return processing in this rule to ensure that any such matches
     * can be consumed as whitespace.  Normally such escaped carriage returns
     * would only be found inside strings, but in complex preprocessor
     * replacements, it is very possible that a coding error could leave such
     * characters outside a string in some cases.  Progress 4GL is tolerant of
     * such escaped carriage returns and thus our whitespace rule must also
     * handle this condition.
     * <p>
     * Non-visible ASCII codes decimal 127 and below are matched here as well.
     * <p>
     * This is a top level lexer rule which means that there is an associated
     * <code>WS</code> token.
     * <p>
     * If the {@link #activateHiddenProcessing} is called, then tokens generated
     * using this rule will not be skipped, but instead will flow through to
     * the caller.
     */
    	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = WS;
    		int _saveIndex;

    		{
    		int _cnt1830=0;
    		_loop1830:
    		do {
    			switch ( LA(1)) {
    			case ' ':
    			{
    				match(' ');
    				break;
    			}
    			case '\t':
    			{
    				match('\t');
    				break;
    			}
    			case '\r':
    			{
    				match('\r');
    				break;
    			}
    			case '\n':
    			{
    				match('\n');
    				newline();
    				break;
    			}
    			case '\u0000':  case '\u0001':  case '\u0002':  case '\u0003':
    			case '\u0004':  case '\u0005':  case '\u0006':  case '\u0007':
    			case '\u0008':  case '\u000b':  case '\u000c':  case '\u000e':
    			case '\u000f':  case '\u0010':  case '\u0011':  case '\u0012':
    			case '\u0013':  case '\u0014':  case '\u0015':  case '\u0016':
    			case '\u0017':  case '\u0018':  case '\u0019':  case '\u001a':
    			case '\u001b':  case '\u001c':  case '\u001d':  case '\u001e':
    			case '\u001f':  case '\u007f':
    			{
    				mJUNK(false);
    				break;
    			}
    			default:
    			{
    				if ( _cnt1830>=1 ) { break _loop1830; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    			}
    			}
    			_cnt1830++;
    		} while (true);
    		}
    		if (!hidden) _ttype =  Token.SKIP;
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches non-visible ASCII codes that should be silently ignored. Extended
     * ASCII characters are NOT matched here. This is text that should not appear
     * in 4GL outside of a string or comment.
     */
    	protected final void mJUNK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = JUNK;
    		int _saveIndex;

    		switch ( LA(1)) {
    		case '\u0000':  case '\u0001':  case '\u0002':  case '\u0003':
    		case '\u0004':  case '\u0005':  case '\u0006':  case '\u0007':
    		case '\u0008':
    		{
    			matchRange('\000','\010');
    			break;
    		}
    		case '\u000b':  case '\u000c':
    		{
    			matchRange('\013','\014');
    			break;
    		}
    		case '\u000e':  case '\u000f':  case '\u0010':  case '\u0011':
    		case '\u0012':  case '\u0013':  case '\u0014':  case '\u0015':
    		case '\u0016':  case '\u0017':  case '\u0018':  case '\u0019':
    		case '\u001a':  case '\u001b':  case '\u001c':  case '\u001d':
    		case '\u001e':  case '\u001f':
    		{
    			matchRange('\016','\037');
    			break;
    		}
    		case '\u007f':
    		{
    			match('\177');
    			break;
    		}
    		default:
    		{
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches any tilde character '~' (that is not in a string or comment) and sets the token type
     * to <code>skip</code> which drops such characters from the token stream. This is consistent
     * with how Progress handles such characters.  This also will match a '~' followed by either
     * quote char. This can be seen in 4GL code (but it usually is only valid as part of a shell
     * command line).  If this construct is matched the token type is {@code UNKNOWN_TOKEN}.
     * <p>
     * This is a top level lexer rule which means that there is an associated <code>TILDE</code>
     * token, however these will never be seen by the parser.
     * <p>
     * If the {@link #activateHiddenProcessing} is called, then tokens generated using this rule
     * will not be skipped, but instead will flow through to the caller.
     */
    	public final void mTILDE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = TILDE;
    		int _saveIndex;

    		{
    		if ((LA(1)=='~') && (LA(2)=='"')) {
    			match('~');
    			match('\"');
    			_ttype = UNKNOWN_TOKEN;
    		}
    		else if ((LA(1)=='~') && (LA(2)=='\'')) {
    			match('~');
    			match('\'');
    			_ttype = UNKNOWN_TOKEN;
    		}
    		else if ((LA(1)=='~') && (true)) {
    			match('~');
    			if (!hidden) _ttype = Token.SKIP;
    		}
    		else {
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}

    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches an entire comment, including any nested comments.  The resulting
     * token is set to &quot;skip&quot; so that the parser will not ever see
     * comments in the token stream.  This supports both the "slash star" and the
     * "slash slash" comment styles.
     * <p>
     * The lexer's internal line counter is updated whenever a newline character
     * is encountered.
     * <p>
     * Of great importance is the fact that the closure subrule for the contents
     * of a comment <b>must not operate on a greedy basis</b>.  Being greedy
     * means that the loop will consume all possible matches to its rule
     * without regard to the end of loop condition.  This is the default way
     * that the lexer works, but since this loop can match any character (we
     * use the wildcard character because any character can be embedded in a
     * comment), a greedy loop would not ever be able to detect its end
     * condition.  Instead we turn off greedy mode and this makes the loop
     * watch for the matching comment close sequence of characters.  Note that
     * nested comments are possible by recursively referencing this same rule
     * inside the comment contents subrule.
     * <p>
     * Whitespace is maintained inside the resulting comment text and the lexer's
     * line counter is properly incremented upon encountering a newline.
     * <p>
     * This is a top level lexer rule which means that there is an associated
     * <code>COMMENT</code> token.
     * <p>
     * If the {@link #activateHiddenProcessing} is called, then tokens generated
     * using this rule will not be skipped, but instead will flow through to
     * the caller.
     */
    	public final void mCOMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = COMMENT;
    		int _saveIndex;

    		mCMT_OPEN(false);
    		{
    		_loop1835:
    		do {
    			// nongreedy exit test
    			if ((LA(1)=='*') && (LA(2)=='/') && (true) && (true)) break _loop1835;
    			if ((LA(1)=='/') && (LA(2)=='*') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && ((LA(4) >= '\u0000' && LA(4) <= '\ufffe'))) {
    				mCOMMENT(false);
    			}
    			else if ((LA(1)=='\n') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match('\n');
    				newline();
    			}
    			else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				matchNot(EOF_CHAR);
    			}
    			else {
    				break _loop1835;
    			}

    		} while (true);
    		}
    		mCMT_CLOSE(false);

    		if (!hidden)
    		_ttype =  Token.SKIP;

    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the open comment sequence of characters: <code>/&#042;</code>
     */
    	protected final void mCMT_OPEN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = CMT_OPEN;
    		int _saveIndex;

    		match("/*");
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the close comment sequence of characters: <code>&#042;/</code>
     */
    	protected final void mCMT_CLOSE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = CMT_CLOSE;
    		int _saveIndex;

    		match("*/");
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches various string types depending upon the processing mode:
     * <ul>
     *    <li>in <b>raw</b> processing mode, matches a double-quoted string
     *        encoded string which represents encoded binary (i.e., raw) data,
     *        setting the token type to <code>RAW_STRING</code>;  otherwise
     *    <li>in <b>export</b> processing mode, matches a double-quoted string
     *        which represents a Progress string as it would appear at runtime,
     *        except that embedded double quotes are doubled up;  otherwise
     *    <li>matches a single or double quoted string followed by any (optional)
     *        string options.
     * </ul>
     * <p>
     * This is a top level lexer rule which means that there is an associated
     * <code>STRING</code> token.
     *
     * @see    "mRSTRING"
     * @see    "mXSTRING"
     * @see    "mSSTRING"
     * @see    "mDSTRING"
     * @see    "mSTR_OPTIONS"
     */
    	public final void mSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = STRING;
    		int _saveIndex;

    		{
    		if (((LA(1)=='"') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( raw )) {
    			mRSTRING(false);
    			_ttype = RAW_STRING;
    		}
    		else if (((LA(1)=='"') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( export )) {
    			mXSTRING(false);
    		}
    		else if ((LA(1)=='"'||LA(1)=='\'') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    			{
    			switch ( LA(1)) {
    			case '\'':
    			{
    				mSSTRING(false);
    				break;
    			}
    			case '"':
    			{
    				mDSTRING(false);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			if ((LA(1)==':')) {
    				mSTR_OPTIONS(false);
    			}
    			else {
    			}

    			}
    		}
    		else {
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}

    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * This rule is only invoked when in raw processing mode. Raw strings
     * represent encoded binary data.
     * <p>
     * Matches an opening double quote, arbitrary contents and an ending double
     * quote.  Opening and closing double quotes are discarded.
     * <p>
     * Currently, no assumptions are made about the contents of the string,
     * except that it will not contain an instance of a double quote, since this
     * is the end delimiter.  All other data is accepted exactly as is.
     * Currently, no decoding is performed.
     */
    	protected final void mRSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = RSTRING;
    		int _saveIndex;

    		{
    		_saveIndex=text.length();
    		match('\"');
    		text.setLength(_saveIndex);
    		{
    		_loop1953:
    		do {
    			if ((_tokenSet_3.member(LA(1)))) {
    				matchNot('\"');
    			}
    			else {
    				break _loop1953;
    			}

    		} while (true);
    		}
    		_saveIndex=text.length();
    		match('\"');
    		text.setLength(_saveIndex);
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * This rule is only invoked when in export processing mode. Export strings
     * are essentially runtime strings which have no escape sequences, except
     * an embedded double quote (") is doubled up ("") to avoid confusion with
     * the enclosing delimiter.
     * <p>
     * Matches an opening double quote, arbitrary contents and an ending double
     * quote.  Two contiguous double quote characters are accepted as contents
     * (they do not terminate the string), but they are collapsed into a single
     * quote character.  Opening and closing double quotes are discarded.
     * <p>
     * Any newlines inside the string are identified and the lexer's internal
     * newline counter is properly maintained.
     * <p>
     * Tabs and spaces and all non-printing characters are maintained inside
     * strings (including embedded binary control characters).
     */
    	protected final void mXSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = XSTRING;
    		int _saveIndex;

    		{
    		_saveIndex=text.length();
    		match('\"');
    		text.setLength(_saveIndex);
    		{
    		_loop1949:
    		do {
    			if ((LA(1)=='"') && (LA(2)=='"')) {
    				_saveIndex=text.length();
    				match("\"\"");
    				text.setLength(_saveIndex);
    				append("\"");
    			}
    			else if ((LA(1)=='\n')) {
    				match('\n');
    				newline();
    			}
    			else if ((_tokenSet_4.member(LA(1)))) {
    				matchNot('\"');
    			}
    			else {
    				break _loop1949;
    			}

    		} while (true);
    		}
    		_saveIndex=text.length();
    		match('\"');
    		text.setLength(_saveIndex);
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches an opening single quote, arbitrary contents and an ending single
     * quote.  Two contiguous single quote characters and an escape prefixed
     * single quote character are accepted as contents (they do not terminate
     * the string).
     * <p>
     * Any newlines inside the string are identified and the lexer's internal
     * newline counter is properly maintained.  Note that all such newlines
     * are maintained in the output string because these are the escaped chars
     * that have been left behind by the preprocessor.  If such characters are not
     * escaped, then the preprocessor removes such chars (carriage returns and
     * line feeds).  This is how Progress 4GL handles these characters.  This
     * means that in a raw source file that has not been preprocessed, a string
     * literal can be split across any number of lines and the Progress
     * preprocessor will put the string back together, ignoring the carriage
     * returns and newlines.
     * <p>
     * Tilde and the backslash can BOTH be Progress escape characters and as such,
     * they need special attention. Backslash is only honored if UNIX escapes
     * mode is set on. In particular, this rule must separately match 4 or 8
     * constructs as part of a string depending on which escape sequences are
     * honored.
     * <p>
     * <pre>
     *    ~'
     *    '~'   (probably a bug in the 4GL)
     *    \'
     *    '\'   (probably a bug in the 4GL)
     *    ~~
     *    ~\
     *    \\
     *    \~
     *    ~
     *    \
     * </pre>
     * <p>
     * The first 4 are a way of embedding a quote in a string.  The next 4 are
     * important because if this rule were to encounter '~~', '\\', '~\' or '\~'
     * (which are valid strings) the rule would consume the first escape and then
     * encounter an escaped quote which would not terminate the string properly,
     * leading to a non-ending string.  So this rule matches on any escaped escape
     * char to eliminate this situation.  Finally, a single ~ or \ that is not
     * followed by a &quot; or a duplicate escape char is matched as a single
     * character.  This is required (one may think that the closure rule
     * should handle this case) because when ANTLR sees a ~ or \ in the leftmost
     * position of the alternatives, it DOES NOT include it in the list of
     * 'everything that is not a closing quote'.  Likewise \n is not included.
     * Of course, these tilde constructions must be placed in a specific order
     * and if so, the ambiguity warnings that ANTLR reports can be disabled.
     * <p>
     * The greedy option does not need to be disabled here as the closure rule
     * termination is built into the subrule itself: it accepts anything that
     * isn't an unescaped single quote character (see above).
     * <p>
     * Tabs and spaces are maintained inside strings.
     */
    	protected final void mSSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = SSTRING;
    		int _saveIndex;

    		{
    		match('\'');
    		{
    		_loop1940:
    		do {
    			if ((LA(1)=='~') && (LA(2)=='\'') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match("~\'");
    			}
    			else if ((LA(1)=='~') && (LA(2)=='~') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match("~~");
    			}
    			else if ((LA(1)=='~') && (LA(2)=='\\') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match("~\\");
    			}
    			else if (((LA(1)=='\\') && (LA(2)=='\'') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( unixEscapes )) {
    				match("\\\'");
    			}
    			else if (((LA(1)=='\\') && (LA(2)=='\\') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( unixEscapes )) {
    				match("\\\\");
    			}
    			else if (((LA(1)=='\\') && (LA(2)=='~') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( unixEscapes )) {
    				match("\\~");
    			}
    			else if (((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( schema )) {
    				_saveIndex=text.length();
    				match("\r\n");
    				text.setLength(_saveIndex);

    				append(' ');
    				newline();

    			}
    			else if (((LA(1)=='\'') && (LA(2)=='~'))&&( LA(3) == '\'' )) {
    				match("\'~\'");
    			}
    			else if ((LA(1)=='~') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    				match('~');
    			}
    			else if (((LA(1)=='\'') && (LA(2)=='\\'))&&( unixEscapes && LA(3) == '\'' )) {
    				match("\'\\\'");
    			}
    			else if ((LA(1)=='\\') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    				match('\\');
    			}
    			else if ((LA(1)=='\'') && (LA(2)=='\'')) {
    				match("\'\'");
    			}
    			else if (((LA(1)=='\n'||LA(1)=='\r') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( schema )) {
    				{
    				switch ( LA(1)) {
    				case '\n':
    				{
    					_saveIndex=text.length();
    					match('\n');
    					text.setLength(_saveIndex);
    					break;
    				}
    				case '\r':
    				{
    					_saveIndex=text.length();
    					match('\r');
    					text.setLength(_saveIndex);
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}

    				append(' ');
    				newline();

    			}
    			else if ((LA(1)=='\n') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    				match('\n');
    				newline();
    			}
    			else if ((_tokenSet_5.member(LA(1)))) {
    				matchNot('\'');
    			}
    			else {
    				break _loop1940;
    			}

    		} while (true);
    		}
    		match('\'');
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches an opening double quote, arbitrary contents and an ending double
     * quote.  Two contiguous double quote characters and an escape prefixed
     * double quote character are accepted as contents (they do not terminate
     * the string).
     * <p>
     * Any newlines inside the string are identified and the lexer's internal
     * newline counter is properly maintained.  Note that all such newlines
     * are maintained in the output string because these are the escaped chars
     * that have been left behind by the preprocessor.  If such characters are not
     * escaped, then the preprocessor removes such chars (carriage returns and
     * line feeds).  This is how Progress 4GL handles these characters.  This
     * means that in a raw source file that has not been preprocessed, a string
     * literal can be split across any number of lines and the Progress
     * preprocessor will put the string back together, ignoring the carriage
     * returns and newlines.
     * <p>
     * Tilde and the backslash can BOTH be Progress escape characters and as such,
     * they need special attention. Backslash is only honored if UNIX escapes
     * mode is set on. In particular, this rule must separately match 4 or 8
     * constructs as part of a string depending on which escape sequences are
     * honored.
     * <p>
     * <pre>
     *    ~&quot;
     *    &quot;~&quot;  (probably a bug in the 4GL)
     *    \&quot;
     *    &quot;\&quot;  (probably a bug in the 4GL)
     *    ~~
     *    ~\
     *    \\
     *    \~
     *    ~
     *    \
     * </pre>
     * <p>
     * The first 4 are a way of embedding a quote in a string.  The next 4 are
     * important because if this rule were to encounter '~~', '\\', '~\' or '\~'
     * (which are valid strings) the rule would consume the first escape and then
     * encounter an escaped quote which would not terminate the string properly,
     * leading to a non-ending string.  So this rule matches on any escaped escape
     * char to eliminate this situation.  Finally, a double ~ or \ that is not
     * followed by a &quot; or a duplicate escape char is matched as a double
     * character.  This is required (one may think that the closure rule
     * should handle this case) because when ANTLR sees a ~ or \ in the leftmost
     * position of the alternatives, it DOES NOT include it in the list of
     * 'everything that is not a closing quote'.  Likewise \n is not included.
     * Of course, these tilde constructions must be placed in a specific order
     * and if so, the ambiguity warnings that ANTLR reports can be disabled.
     * <p>
     * The greedy option does not need to be disabled here as the closure rule
     * termination is built into the subrule itself: it accepts anything that
     * isn't an unescaped double quote character (see above).
     * <p>
     * Tabs and spaces are maintained inside strings.
     */
    	protected final void mDSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = DSTRING;
    		int _saveIndex;

    		{
    		match('\"');
    		{
    		_loop1945:
    		do {
    			if ((LA(1)=='~') && (LA(2)=='"') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match("~\"");
    			}
    			else if ((LA(1)=='~') && (LA(2)=='~') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match("~~");
    			}
    			else if ((LA(1)=='~') && (LA(2)=='\\') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
    				match("~\\");
    			}
    			else if (((LA(1)=='\\') && (LA(2)=='"') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( unixEscapes )) {
    				match("\\\"");
    			}
    			else if (((LA(1)=='\\') && (LA(2)=='\\') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( unixEscapes )) {
    				match("\\\\");
    			}
    			else if (((LA(1)=='\\') && (LA(2)=='~') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( unixEscapes )) {
    				match("\\~");
    			}
    			else if (((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))&&( schema )) {
    				_saveIndex=text.length();
    				match("\r\n");
    				text.setLength(_saveIndex);

    				append(' ');
    				newline();

    			}
    			else if (((LA(1)=='"') && (LA(2)=='~'))&&( LA(3) == '"' )) {
    				match("\"~\"");
    			}
    			else if ((LA(1)=='~') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    				match('~');
    			}
    			else if (((LA(1)=='"') && (LA(2)=='\\'))&&( unixEscapes && LA(3) == '"' )) {
    				match("\"\\\"");
    			}
    			else if ((LA(1)=='\\') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    				match('\\');
    			}
    			else if ((LA(1)=='"') && (LA(2)=='"')) {
    				match("\"\"");
    			}
    			else if (((LA(1)=='\n'||LA(1)=='\r') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( schema )) {
    				{
    				switch ( LA(1)) {
    				case '\n':
    				{
    					_saveIndex=text.length();
    					match('\n');
    					text.setLength(_saveIndex);
    					break;
    				}
    				case '\r':
    				{
    					_saveIndex=text.length();
    					match('\r');
    					text.setLength(_saveIndex);
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}

    				append(' ');
    				newline();

    			}
    			else if ((LA(1)=='\n') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
    				match('\n');
    				newline();
    			}
    			else if ((_tokenSet_6.member(LA(1)))) {
    				matchNot('\"');
    			}
    			else {
    				break _loop1945;
    			}

    		} while (true);
    		}
    		match('\"');
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the options that can be appended to a Progress string literal.
     * These options consist of 4 parts, some of which are optional.  String
     * options always start with a ':' which must follow the string's ending
     * single or double quote with no intervening whitespace.  After that
     * colon, there must be one or more of a justification, size allocation in
     * characters and a flag noting if this string is translatable or not.
     * <pre>
     *    justification          'r' | 'l' | 'c' | 't'
     *    translatable           'u' | 'x'
     *    size                   integer literal (one or more contiguous digits)
     * </pre>
     * <p>
     * The use of 'X' is an undocumented feature of the 4GL and it can only appear
     * if 'U' is not present. The meaning of this is not yet known.
     * <p>
     * These options can come in any order and at least one of them must appear.
     * This causes some problems since there is no simple syntax to specify
     * such conditions in the grammar.  Whitespace cannot be placed between any
     * of the options.
     * <p>
     * In addition, just as the lookahead for the <code>mDEC_LITERAL</code> rule
     * could incorrectly 'pull' processing down into that rule as a false match,
     * so too can this happen here. For this reason, the possible alternatives
     * are specified and then the empty alternative is used to detect a false
     * match and the lexer's stream input is manually reset to backup and restart
     * processing at the top-level.
     * <p>
     * None of this would be possible if comments or whitespace were allowed in
     * string options.  They are not.
     */
    	protected final void mSTR_OPTIONS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = STR_OPTIONS;
    		int _saveIndex;

    		// save state *before* matching of ':' so we can reset if it is
    		// really supposed to be a statement separator and not string
    		// options as we first thought
    		boolean commitFlag = true;
    		int     back       = mark();
    		String  save       = getText();

    		{
    		match(':');
    		{
    		if ((_tokenSet_7.member(LA(1))) && (LA(2)=='u'||LA(2)=='x')) {
    			{
    			switch ( LA(1)) {
    			case 'r':
    			{
    				match('r');
    				break;
    			}
    			case 'l':
    			{
    				match('l');
    				break;
    			}
    			case 'c':
    			{
    				match('c');
    				break;
    			}
    			case 't':
    			{
    				match('t');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			switch ( LA(1)) {
    			case 'u':
    			{
    				match('u');
    				break;
    			}
    			case 'x':
    			{
    				match('x');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			_loop1960:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					break _loop1960;
    				}

    			} while (true);
    			}
    		}
    		else if ((_tokenSet_7.member(LA(1))) && ((LA(2) >= '0' && LA(2) <= '9'))) {
    			{
    			switch ( LA(1)) {
    			case 'r':
    			{
    				match('r');
    				break;
    			}
    			case 'l':
    			{
    				match('l');
    				break;
    			}
    			case 'c':
    			{
    				match('c');
    				break;
    			}
    			case 't':
    			{
    				match('t');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			int _cnt1963=0;
    			_loop1963:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					if ( _cnt1963>=1 ) { break _loop1963; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}

    				_cnt1963++;
    			} while (true);
    			}
    			{
    			switch ( LA(1)) {
    			case 'u':
    			{
    				match('u');
    				break;
    			}
    			case 'x':
    			{
    				match('x');
    				break;
    			}
    			default:
    				{
    				}
    			}
    			}
    		}
    		else if ((LA(1)=='u'||LA(1)=='x') && (_tokenSet_7.member(LA(2)))) {
    			{
    			switch ( LA(1)) {
    			case 'u':
    			{
    				match('u');
    				break;
    			}
    			case 'x':
    			{
    				match('x');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			switch ( LA(1)) {
    			case 'r':
    			{
    				match('r');
    				break;
    			}
    			case 'l':
    			{
    				match('l');
    				break;
    			}
    			case 'c':
    			{
    				match('c');
    				break;
    			}
    			case 't':
    			{
    				match('t');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			_loop1969:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					break _loop1969;
    				}

    			} while (true);
    			}
    		}
    		else if ((LA(1)=='u'||LA(1)=='x') && ((LA(2) >= '0' && LA(2) <= '9'))) {
    			{
    			switch ( LA(1)) {
    			case 'u':
    			{
    				match('u');
    				break;
    			}
    			case 'x':
    			{
    				match('x');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			int _cnt1972=0;
    			_loop1972:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					if ( _cnt1972>=1 ) { break _loop1972; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}

    				_cnt1972++;
    			} while (true);
    			}
    			{
    			switch ( LA(1)) {
    			case 'r':
    			{
    				match('r');
    				break;
    			}
    			case 'l':
    			{
    				match('l');
    				break;
    			}
    			case 'c':
    			{
    				match('c');
    				break;
    			}
    			case 't':
    			{
    				match('t');
    				break;
    			}
    			default:
    				{
    				}
    			}
    			}
    		}
    		else if ((_tokenSet_7.member(LA(1))) && (true)) {
    			{
    			switch ( LA(1)) {
    			case 'r':
    			{
    				match('r');
    				break;
    			}
    			case 'l':
    			{
    				match('l');
    				break;
    			}
    			case 'c':
    			{
    				match('c');
    				break;
    			}
    			case 't':
    			{
    				match('t');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    		}
    		else if ((LA(1)=='u'||LA(1)=='x') && (true)) {
    			{
    			switch ( LA(1)) {
    			case 'u':
    			{
    				match('u');
    				break;
    			}
    			case 'x':
    			{
    				match('x');
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    		}
    		else if (((LA(1) >= '0' && LA(1) <= '9'))) {
    			{
    			int _cnt1976=0;
    			_loop1976:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					if ( _cnt1976>=1 ) { break _loop1976; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}

    				_cnt1976++;
    			} while (true);
    			}
    			{
    			switch ( LA(1)) {
    			case 'c':  case 'l':  case 'r':  case 't':
    			{
    				{
    				{
    				switch ( LA(1)) {
    				case 'r':
    				{
    					match('r');
    					break;
    				}
    				case 'l':
    				{
    					match('l');
    					break;
    				}
    				case 'c':
    				{
    					match('c');
    					break;
    				}
    				case 't':
    				{
    					match('t');
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}
    				{
    				switch ( LA(1)) {
    				case 'u':
    				{
    					match('u');
    					break;
    				}
    				case 'x':
    				{
    					match('x');
    					break;
    				}
    				default:
    					{
    					}
    				}
    				}
    				}
    				break;
    			}
    			case 'u':  case 'x':
    			{
    				{
    				{
    				switch ( LA(1)) {
    				case 'u':
    				{
    					match('u');
    					break;
    				}
    				case 'x':
    				{
    					match('x');
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}
    				{
    				switch ( LA(1)) {
    				case 'r':
    				{
    					match('r');
    					break;
    				}
    				case 'l':
    				{
    					match('l');
    					break;
    				}
    				case 'c':
    				{
    					match('c');
    					break;
    				}
    				case 't':
    				{
    					match('t');
    					break;
    				}
    				default:
    					{
    					}
    				}
    				}
    				}
    				break;
    			}
    			default:
    				{
    				}
    			}
    			}
    		}
    		else {

    			// We match the EMPTY alternative if one of the valid
    			// string options is not found above!!!!!
    			// Abort! Reset state to remove the already matched ':'.
    			commitFlag = false;
    			setText( save );
    			rewind( back );

    		}

    		}
    		}

    		// if we did not rewind, we need to reset our mark without rewinding
    		if ( commitFlag )
    		commit();

    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Match any valid symbol name in the Progress 4GL language or the standalone
     * <code>DIVIDE</code> operator '/'.  This includes the following:
     * <ul>
     *    <li> divide sign '/'
     *    <li> underscore '_' (does not have a token type of its own, it is a
     *         generic symbol if found on its own)
     *    <li> language keywords (reserved and unreserved)
     *    <li> variables (global shared, scoped shared and local)
     *    <li> database, table and field names
     *    <li> user-defined functions
     *    <li> built-in functions of the Progress 4GL
     *    <li> internal procedure names
     *    <li> labels
     *    <li> path and filenames (which include any valid symbol character
     *         as well as '/' or '\' or '.' or '..') which supports absolute
     *         and relative filenames including the special references to
     *         the current directory and the parent directory
     *    <li> single '\' is matched but then discarded (it is never seen by
     *         the parser because its type is set to <code>SKIP</code>
     *    <li> r-code library references in the form
     *         <code>pathname&lt;&lt;membername&gt;&gt;</code>
     *    <li> other user-defined names (e.g. frames, temp-tables etc.)
     * </ul>
     * <p>
     * All symbols must start with an alphabetic character.  Starting in the
     * second character and continuing to a maximum of 32 characters (including
     * the initial character), can be any alphabetic and numeric characters or
     * one of the special symbol characters (<code> # $ % &amp; - _ </code>).
     * <b>Symbols are matched case-insensitively.</b>
     * <p>
     * An exception to the previous rule that a symbol must start with an
     * alphabetic character is for special meta-data entries in the Progress
     * schema dictionary, whose table and field names start with an underscore.
     * For this reason, such entries are allowed more generally such that the
     * rule as implemented is: the first letter of every symbol must be an
     * alphabetic character or an underscore.
     * <p>
     * Another exception to the previous rule that a symbol must start with an
     * alphabetic character is for a filename. Filenames <b>may also</b> start
     * with the '/' or '\' characters (in which case they are absolute filenames).
     * The second and following characters in filenames can include '/', '\' or
     * '.' in addition to all the special symbol characters listed above. Filenames
     * may also include a "naked" embedded double quote or single quote character
     * so long as there is no intervening whitespace.  These embedded quotes cannot
     * be the leading character but can appear deeper in and they are not considered
     * the start of a string.  These can be referenced in RUN statements and as
     * procedure names (in an internal definition or as an external filename).
     * <p>
     * In addition, DOS and Windows filenames can start with a drive letter
     * followed by a ':' as in 'c:'.  This construct is matched as a symbol
     * followed by a colon.  This is needed to allow single character variable
     * names + attribute or method calls to properly work in the parser. The
     * difficulty with putting the whole thing together again into a single
     * filename is left to the {@link ProgressParser#filename} rule.
     * <p>
     * <b>Note that there are many characters that are not allowed in filenames
     * at this time.  This is an artificial limitation designed to keep the
     * current lexer simple and compatible with the known/common cases of
     * filenames while not introducing too many potential ambiguities.
     * Examples of characters that are not matched include: '~', '!', '@', '^',
     * '+', '='.  The general rule: if the character is not a valid symbol char,
     * '/', '\', '.' or '..' then it is not matched.</b>  This can be changed if
     * necessary, but the decision was made to defer such handling until the
     * need arises. When a filename is detected the token type is set to
     * <code>FILENAME</code>.  Both relative and absolute filenames are matched
     * by this rule (except for the drive letter component as noted above).
     * <p>
     * Since the '/' character is matched in this rule, an inherent ambiguity
     * was created with any top level <code>DIVIDE</code> rule that matches '/'.
     * For this reason, the ambiguity was resolved by matching on a standalone
     * '/' in this rule and setting the resulting token type to
     * <code>DIVIDE</code>.  The top level <code>DIVIDE</code> rule was
     * removed.
     * <p>
     * The '\' is a special case in Progress.  This character can be inserted
     * anywhere and it is simply ignored.  This feature is supported in this
     * rule as well, but matching a standalone backslash and setting it's type
     * to <code>SKIP</code>.  Note that a backslash that is part of a larger
     * filename, is NOT skipped.
     * <p>
     * To avoid lexer non-determinism, any filename that starts with './', '../',
     * '.\' or '..\' is actually matched at the top level by
     * {@link #mNUM_LITERAL}.  This is needed because the <code>DOT</code> in the
     * first position conflicts.  So instead, once <code>mNUM_LITERAL</code>
     * matches one of these strings, it includes this rule optionally.  This
     * allows all normal filename processing to occur as needed but doesn't
     * require it since the previous string can legitimately stand alone.
     * <p>
     * R-code library references are matched with the format
     * <code>pathname&lt;&lt;membername&gt;&gt;</code>.  This allows any filename
     * to be specified as a prefix and then the library member name followed
     * as a suffix, but contained in the unambiguous double angle brackets.
     * When this construction is matched, the token type is set to
     * <code>LIBRARY_REF</code>.
     * <p>
     * A special case exists for partially or fully qualified database symbols.
     * Such symbols are comprised of 2 or 3 regular symbols, each separated
     * by a '.' and no whitespace.  This method recognizes such optional
     * constructions and sets the token type to <code>DB_SYMBOL</code>.  In
     * order to make this extra check work, the optional section (following the
     * first or main symbol definition) is differentiated using a semantic
     * predicate. This only allows the database symbol matching if the following
     * conditions hold:
     * <ul>
     *    <li> a <code>DOT</code> character is found after the symbol without
     *         any intervening whitespace
     *    <li> the next character after the <code>DOT</code> is an alphabetic
     *         character (it can't be numeric or a special symbol because each
     *         part of the qualified database symbol name must follow the
     *         standard rules (see above) for symbol naming
     * </ul>
     * <p>
     * There is a second optional section nested inside the first one, which
     * handles the condition where there is a fully qualified field name.  The
     * resulting possible constructions are:
     * <pre>
     * user-defined symbol or unqualified db/table/field name    --&gt; sym
     * fully qualified table or partially qualified field name   --&gt; sym.sym
     * fully qualified field name                                --&gt; sym.sym.sym
     * </pre>
     * <p>
     * Any unqualified database, table or field names will be lexed as a standard
     * symbol (which is the default token type). But in any case where a simple
     * symbol is followed by a '.' AND an alphabetic character with no
     * intervening whitespace, this is known to be a qualified database name and
     * it <b>cannot</b> be a generic symbol or language keyword.  <b>If there is
     * ever a testcase found that does not follow this rule, this method will
     * break, badly!</b>
     * <p>
     * It is also important to note that any relative filename that does not
     * include any path separator ('/' or '\') and which does not have any more
     * than 2 '.' characters will be matched as a <code>DB_SYMBOL</code> due to
     * inherent ambiguity in the Progress decision to use the '.' as the
     * database qualifier.  This means that the parser must be aware that some
     * filenames can appear as database symbols.
     * <p>
     * Most importantly, once a symbol has been found, a keyword lookup occurs
     * and the token type is overridden from the default (<code>SYMBOL</code>)
     * to the artificial token type associated with the keyword (see
     * <code>initializeKeywordDictionary</code>).  The parser may subsequently
     * override this token type yet again, but this is the extent of the lexer's
     * symbol resolution.  <b>Keyword token types take precedence over the
     * default token type <code>SYMBOL</code>, however only <code>SYMBOL</code>
     * types are overridden since there are no circumstances in which there are
     * language keywords that can match database symbols, filenames or library
     * references.</b>  All
     * <code>DIVIDE, DB_SYMBOL, FILENAME and LIBRARY_REF</code> token types
     * bypass the keyword lookup and override.
     * <p>
     * See the overview for a discussion of how and why the symbol resolution
     * in this method is limited to keywords and the
     * <code>SYMBOL, DIVIDE, DB_SYMBOL, FILENAME and LIBRARY_REF</code> token
     * types.
     * <p>
     * This is a top level lexer rule which means that there is an associated
     * <code>SYMBOL</code> token. The
     * <code>DIVIDE, DB_SYMBOL, FILENAME and LIBRARY_REF</code> tokens are
     * artificially created in the parser so that they can be manually set
     * here as an override.
     * <p>
     * Standalone backslashes are set to <code>skip</code> by default.  However,
     * if the {@link #activateHiddenProcessing} is called, then tokens generated
     * using this rule will not be skipped, but instead will flow through to
     * the caller.
     *
     * @see    "mLETTER"
     * @see    "mDIGIT"
     * @see    "mSYM_CHAR"
     * @see     Keyword
     * @see     KeywordDictionary
     * @see     SymbolResolver
     */
    	public final void mSYMBOL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = SYMBOL;
    		int _saveIndex;

    		int stype = SYMBOL;

    		{
    		switch ( LA(1)) {
    		case 'a':  case 'b':  case 'c':  case 'd':
    		case 'e':  case 'f':  case 'g':  case 'h':
    		case 'i':  case 'j':  case 'k':  case 'l':
    		case 'm':  case 'n':  case 'o':  case 'p':
    		case 'q':  case 'r':  case 's':  case 't':
    		case 'u':  case 'v':  case 'w':  case 'x':
    		case 'y':  case 'z':
    		{
    			mLETTER(false);
    			break;
    		}
    		case '_':
    		{
    			match('_');
    			break;
    		}
    		default:
    			if ((LA(1)=='/') && (_tokenSet_8.member(LA(2))) && (true) && (true)) {
    				match('/');
    				mVALID_SYM_CHAR(false);
    				stype = FILENAME;
    			}
    			else if (((LA(1)=='/') && (LA(2)=='/') && (true) && (true))&&( allowSlashSlash )) {
    				mSLASH_SLASH(false);
    				stype = COMMENT;
    				{
    				_loop1844:
    				do {
    					if ((_tokenSet_9.member(LA(1))) && (true) && (true) && (true)) {
    						{
    						match(_tokenSet_9);
    						}
    					}
    					else {
    						break _loop1844;
    					}

    				} while (true);
    				}
    			}
    			else if ((LA(1)=='\\') && (_tokenSet_8.member(LA(2))) && (true) && (true)) {
    				match('\\');
    				mVALID_SYM_CHAR(false);
    				stype = FILENAME;
    			}
    			else if ((LA(1)=='/') && (true) && (true) && (true)) {
    				match('/');
    				stype = DIVIDE;
    			}
    			else if ((LA(1)=='\\') && (true) && (true) && (true)) {
    				match('\\');
    				stype = BACKSLASH;
    			}
    		else {
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		}
    		{
    		_loop1846:
    		do {
    			switch ( LA(1)) {
    			case '#':  case '$':  case '%':  case '&':
    			case '-':  case '0':  case '1':  case '2':
    			case '3':  case '4':  case '5':  case '6':
    			case '7':  case '8':  case '9':  case '_':
    			case 'a':  case 'b':  case 'c':  case 'd':
    			case 'e':  case 'f':  case 'g':  case 'h':
    			case 'i':  case 'j':  case 'k':  case 'l':
    			case 'm':  case 'n':  case 'o':  case 'p':
    			case 'q':  case 'r':  case 's':  case 't':
    			case 'u':  case 'v':  case 'w':  case 'x':
    			case 'y':  case 'z':
    			{
    				mVALID_SYM_CHAR(false);
    				break;
    			}
    			case '\\':
    			{
    				match('\\');
    				stype = FILENAME;
    				break;
    			}
    			default:
    				if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='/') && (true)) {
    					match("../");
    					stype = FILENAME;
    				}
    				else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='\\') && (true)) {
    					match("..\\");
    					stype = FILENAME;
    				}
    				else if ((LA(1)=='.') && (LA(2)=='/') && (true) && (true)) {
    					match("./");
    					stype = FILENAME;
    				}
    				else if ((LA(1)=='.') && (LA(2)=='\\') && (true) && (true)) {
    					match(".\\");
    					stype = FILENAME;
    				}
    				else if (((LA(1)=='/'))&&( stype != BACKSLASH && stype != DIVIDE )) {
    					match('/');
    					stype = FILENAME;
    				}
    				else if (((LA(1)=='"'))&&( LA(2) != ' ' && LA(2) != '\t' && LA(2) != '\r' && LA(2) != '\n' )) {
    					match('\"');
    					stype = FILENAME;
    				}
    				else if (((LA(1)=='\''))&&( LA(2) != ' ' && LA(2) != '\t' && LA(2) != '\r' && LA(2) != '\n' )) {
    					match('\'');
    					stype = FILENAME;
    				}
    				else if (((LA(1)=='.') && (true) && (true) && (true))&&(
                  (LA(2) >= 'a' && LA(2) <= 'z') ||
                  (LA(2) >= '0' && LA(2) <= '9') ||
                  LA(2)  == '#' || LA(2) == '$'  ||
                  LA(2)  == '%' || LA(2) == '&'  ||
                  LA(2)  == '-' || LA(2) == '_'
               )) {
    					match('.');
    					if (stype == SYMBOL) stype = DB_SYMBOL;
    				}
    			else {
    				break _loop1846;
    			}
    			}
    		} while (true);
    		}
    		{
    		if (((LA(1)=='<'))&&( LA(2) == '<' )) {
    			match("<<");
    			mLETTER(false);
    			{
    			_loop1849:
    			do {
    				switch ( LA(1)) {
    				case '#':  case '$':  case '%':  case '&':
    				case '-':  case '0':  case '1':  case '2':
    				case '3':  case '4':  case '5':  case '6':
    				case '7':  case '8':  case '9':  case '_':
    				case 'a':  case 'b':  case 'c':  case 'd':
    				case 'e':  case 'f':  case 'g':  case 'h':
    				case 'i':  case 'j':  case 'k':  case 'l':
    				case 'm':  case 'n':  case 'o':  case 'p':
    				case 'q':  case 'r':  case 's':  case 't':
    				case 'u':  case 'v':  case 'w':  case 'x':
    				case 'y':  case 'z':
    				{
    					mVALID_SYM_CHAR(false);
    					break;
    				}
    				case '.':
    				{
    					match('.');
    					break;
    				}
    				default:
    				{
    					break _loop1849;
    				}
    				}
    			} while (true);
    			}
    			match(">>");
    			stype = LIBRARY_REF;
    		}
    		else {
    		}

    		}

    		// standalone backslash chars must be ignored (they can be
    		// arbitrarily inserted in Progress code and make no difference)
    		if ( stype == BACKSLASH )
    		{
    		if (getText().equals("\\"))
    		{
    		if (!hidden)
    		{
    		// ignore the standalone backslash
    		stype = Token.SKIP;
    		}
    		}
    		else
    		{
    		// backslash is not a valid token to be seen in the parser
    		// in this case, it must really be a filename
    		stype = FILENAME;
    		}
    		}

    		// in order to handle filenames (which can include the '.' char)
    		// we had to make the DB_SYMBOL matching more generic since there
    		// is no way to know in the lexer, whether a simple "hello.p" is
    		// a DB_SYMBOL or a FILENAME; for this reason we add this test to
    		// force something to a FILENAME token type based on finding
    		// a value that couldn't be in a DB_SYMBOL
    		if (stype == DB_SYMBOL)
    		{
    		int     count   = 0;
    		int     index   = 0;
    		boolean invalid = false;
    		String  txt     = new String(text.getBuffer(),_begin,text.length()-_begin);

    		while ( index != -1 )
    		{
    		index = txt.indexOf('.', index+1);
    		if (index != -1)
    		{
    		// this next code works because we know that there will
    		// never be a '.' as the last char of a symbol (not legal
    		// in Progress because this would be ambiguous with '.'
    		// as an end of statement delimiter) --> if this ever
    		// changes, this code will throw an
    		// java.lang.StringIndexOutOfBoundsException
    		char ch = (char) txt.charAt(index+1);
    		if (Character.isLetter(ch) == false && ch != '_')
    		invalid = true;
    		count++;
    		}
    		}

    		if (invalid || count > 2)
    		stype = FILENAME;
    		}

    		// only generic symbols need to be overridden by possible keyword
    		// matches; partially/fully qualified database object (table or
    		// field) names OR filenames OR the DIVIDE operator OR r-code library
    		// references cannot be keywords, so we bypass this logic
    		if (stype == SYMBOL)
    		{
    		// non-database path which could be a keyword, we bias toward
    		// this outcome due to the keyword-rich design of Progress 4GL
    		Keyword found = sym.lookupKeyword(getText());

    		if (found != null)
    		{
    		// we will *assume* we are a keyword (we may actually be a
    		// user-defined symbol, but we will handle that in the parser
    		stype = found.getTokenType();
    		}
    		}
    		_ttype = stype;

    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches any single character that can appear in the 2nd or later position
     * in a symbol (matches any <code>LETTER, DIGIT or SYM_CHAR</code>). This is
     * simply a helper rule to make references easier.
     */
    	protected final void mVALID_SYM_CHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = VALID_SYM_CHAR;
    		int _saveIndex;

    		switch ( LA(1)) {
    		case 'a':  case 'b':  case 'c':  case 'd':
    		case 'e':  case 'f':  case 'g':  case 'h':
    		case 'i':  case 'j':  case 'k':  case 'l':
    		case 'm':  case 'n':  case 'o':  case 'p':
    		case 'q':  case 'r':  case 's':  case 't':
    		case 'u':  case 'v':  case 'w':  case 'x':
    		case 'y':  case 'z':
    		{
    			mLETTER(false);
    			break;
    		}
    		case '0':  case '1':  case '2':  case '3':
    		case '4':  case '5':  case '6':  case '7':
    		case '8':  case '9':
    		{
    			mDIGIT(false);
    			break;
    		}
    		case '#':  case '$':  case '%':  case '&':
    		case '-':  case '_':
    		{
    			mSYM_CHAR(false);
    			break;
    		}
    		default:
    		{
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the start of a new-style single-line Progress 4GL comment that will extend to the end
     * of the current line.
     */
    	protected final void mSLASH_SLASH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = SLASH_SLASH;
    		int _saveIndex;

    		match('/');
    		match('/');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches any alphabetic character: <code>a - z</code>.
     */
    	protected final void mLETTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = LETTER;
    		int _saveIndex;

    		matchRange('a','z');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the ':' character. This is a top level rule, creating a
     * <code>COLON</code> token type.
     * <p>
     * The hidden token stream can be used to determine whether the colon was
     * followed by whitespace or not.  This is needed in the parser to
     * differentiate between labels (which must always be followed by whitespace)
     * and attributes/methods where the colon cannot be followed by whitespace.
     */
    	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = COLON;
    		int _saveIndex;

    		match(':');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '::' non-static database reference "operator". This is a top
     * level rule, creating a <code>DB_REF_NON_STATIC</code> token type.
     * <p>
     * The hidden token stream can be used to determine whether the colon was
     * followed by whitespace or not.  This is needed in the parser to
     * differentiate between labels (which must always be followed by whitespace)
     * and attributes/methods where the colon cannot be followed by whitespace.
     */
    	public final void mDB_REF_NON_STATIC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = DB_REF_NON_STATIC;
    		int _saveIndex;

    		match("::");
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the ',' character. This is a top level rule, creating a
     * <code>COMMA</code> token type.
     */
    	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = COMMA;
    		int _saveIndex;

    		match(',');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '=' character. This is a top level rule, creating a
     * <code>EQUALS</code> token type.
     */
    	public final void mEQUALS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = EQUALS;
    		int _saveIndex;

    		match('=');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '*=' operator. This is a top-level rule, creating a
     * <code>MULT_ASSIGN</code> token type.
     */
    	public final void mMULT_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = MULT_ASSIGN;
    		int _saveIndex;

    		match('*');
    		match('=');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '+=' operator. This is a top-level rule, creating a
     * <code>PLUS_ASSIGN</code> token type.
     */
    	public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = PLUS_ASSIGN;
    		int _saveIndex;

    		match('+');
    		match('=');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '-=' operator. This is a top-level rule, creating a
     * <code>MINUS_ASSIGN</code> token type.
     */
    	public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = MINUS_ASSIGN;
    		int _saveIndex;

    		match('-');
    		match('=');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '/=' operator. This is a top-level rule, creating a
     * <code>DIV_ASSIGN</code> token type.
     */
    	public final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = DIV_ASSIGN;
    		int _saveIndex;

    		match('/');
    		match('=');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '&lt;&gt;' character sequence. This is a top level rule, creating a
     * <code>NOT_EQ</code> token type.
     */
    	public final void mNOT_EQ(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = NOT_EQ;
    		int _saveIndex;

    		match("<>");
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '&gt;' character. This is a top level rule, creating a
     * <code>GT</code> token type.
     */
    	public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = GT;
    		int _saveIndex;

    		match('>');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '&lt;' character. This is a top level rule, creating a
     * <code>LT</code> token type.
     */
    	public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = LT;
    		int _saveIndex;

    		match('<');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '&gt;=' character sequence. This is a top level rule, creating
     * a <code>GTE</code> token type.
     */
    	public final void mGTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = GTE;
    		int _saveIndex;

    		match(">=");
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '&lt;=' character sequence. This is a top level rule, creating
     * a <code>LTE</code> token type.
     */
    	public final void mLTE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = LTE;
    		int _saveIndex;

    		match("<=");
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '(' character. This is a top level rule, creating a
     * <code>LPARENS</code> token type.
     */
    	public final void mLPARENS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = LPARENS;
    		int _saveIndex;

    		match('(');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the ')' character. This is a top level rule, creating a
     * <code>RPARENS</code> token type.
     */
    	public final void mRPARENS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = RPARENS;
    		int _saveIndex;

    		match(')');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '[' character. This is a top level rule, creating a
     * <code>LBRACKET</code> token type.
     */
    	public final void mLBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = LBRACKET;
    		int _saveIndex;

    		match('[');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the ']' character. This is a top level rule, creating a
     * <code>RBRACKET</code> token type.
     */
    	public final void mRBRACKET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = RBRACKET;
    		int _saveIndex;

    		match(']');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '*' character. This is a top level rule, creating a
     * <code>MULTIPLY</code> token type.
     */
    	public final void mMULTIPLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = MULTIPLY;
    		int _saveIndex;

    		match('*');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '@' character.  This is a top level rule, creating an
     * <code>AT</code> token type.
     */
    	public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = AT;
    		int _saveIndex;

    		match('@');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the '^' character.  This is a top level rule, creating an
     * <code>CARET</code> token type.
     */
    	public final void mCARET(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = CARET;
    		int _saveIndex;

    		match('^');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches the unknown value '?'. This is a top level rule, creating a
     * <code>UNKNOWN_VAL</code> token type.
     */
    	public final void mUNKNOWN_VAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = UNKNOWN_VAL;
    		int _saveIndex;

    		match('?');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches all forms of valid integer literals, decimal literals and due to
     * ambiguity, the period character (<code>DOT</code> token), all date
     * literals, the minus sign (<code>MINUS</code> token), the plus sign
     * (<code>PLUS</code>) and all <code>FILENAME</code> tokens that begin with
     * '.' or '..' must be matched here as well.
     * <p>
     * This is a very special method that encapsulates and resolves all ambiguity
     * caused by the different usage of '.' as a decimal point and also as a
     * statement separator.  Likewise it handles the ambiguity presented by the
     * traditional minus/plus operators and the prefixing/postfixing of a
     * negative or positive sign on a numeric or decimal literal.  Finally, it
     * also handles the ambiguity associated with the use of '-' as a separator
     * in a date literal.
     * <p>
     * Scenarios that are matched:
     * <ul>
     *    <li> Matches the '.' character creating a <code>DOT</code> token type.
     *    <li> Matches the following strings as a <code>FILENAME</code> token
     *         type (the following {@link #mSYMBOL} is optional) :
     *       <ul>
     *          <li> './' <code>mSYMBOL</code>
     *          <li> '../' <code>mSYMBOL</code>
     *          <li> '.\' <code>mSYMBOL</code>
     *          <li> '..\' <code>mSYMBOL</code>
     *       </ul>
     *    <li> Matches the '-' character creating a <code>MINUS</code> token type
     *         (if this is not followed by digits or a decimal point and digits).
     *    <li> Matches the '-' character followed by digits as a
     *         <code>NUM_LITERAL</code>.
     *    <li> Matches the '-' character followed by digits and then a '.' and
     *         more digits as a <code>DEC_LITERAL</code>.
     *    <li> Matches the '-' character followed by a '.' and digits as a
     *         <code>DEC_LITERAL</code> token type.
     *    <li> Matches the '+' character creating a <code>PLUS</code> token type
     *         (if this is not followed by digits or a decimal point and digits).
     *    <li> Matches the '+' character followed by digits as a
     *         <code>NUM_LITERAL</code>. The '+' is discarded as syntactic sugar.
     *    <li> Matches the '+' character followed by digits and then a '.' and
     *         more digits as a <code>DEC_LITERAL</code>. The '+' is discarded as
     *         syntactic sugar.
     *    <li> Matches the '+' character followed by a '.' and digits as a
     *         <code>DEC_LITERAL</code> token type. The '+' is discarded as
     *         syntactic sugar.
     *    <li> Matches a sequence of one or more digits (without a decimal point
     *         and additional digits) as an integer literal with a
     *         <code>NUM_LITERAL</code> token type.  There can be an optional
     *         leading negative/positive sign (the cases noted above). If no
     *         leading sign is present, then an optional postfixed sign (negative
     *         or positive) can be present.
     *    <li> Matches a sequence of one or more digits followed by a '.' but
     *         no additional digits, as an integer literal (it does not consume
     *         the following '.' in this case), with a <code>NUM_LITERAL</code>
     *         token type. There can be an optional leading negative/positive
     *         sign (the cases noted above).
     *    <li> Matches one or more numeric digits followed by a decimal point
     *         and another sequence of numeric digits as a decimal constant
     *         with a <code>DEC_LITERAL</code> token type.  There can be an
     *         optional leading negative/positive sign (the cases noted above).
     *         If no leading sign is present, then an optional postfixed sign
     *         (negative or positive) can be present.
     *    <li> Matches a decimal point followed by a sequence of numeric digits
     *         as a decimal constant with a <code>DEC_LITERAL</code> token type.
     *         There can be an optional leading negative/positive sign (the cases
     *         noted above). If no leading sign is present, then an optional
     *         postfixed sign (negative or positive) can be present.
     *    <li> Matches digits followed by a '-', '/' or '.' and one or two digits
     *         as a <code>DATE_LITERAL</code>. If there are no following
     *         digits after the separator, then it is not matched as a date,
     *         instead it is a integer literal followed by an operator.  The
     *         second separator for the year portion is optional, as is the year
     *         itself and there is an optional negative sign for BC dates. The
     *         second separator can also be any of the '-', '/' or '.' characters
     *         and the first and second separators can be any combination of
     *         these characters (the two separators don't have to be the same
     *         character in a single date literal).
     * </ul>
     * <p>
     * The key to this rule is that there cannot be any intervening whitespace
     * between digits and decimal points or between digits and the date separators
     * '-' or '/'.  Likewise, there cannot be any intervening whitespace between
     * a leading or trailing '-' or '+' and the numeric or decimal literal it
     * precedes or follows respectively. In such a case the '-' is lexed as a
     * <code>MINUS</code> token, the '+' is lexed as a <code>PLUS</code> token
     * and the parser must use context to determine if it is a unary or binary
     * operator.
     * <p>
     * By handling the case of '.' (by itself) here instead of in a (more
     * intuitive) dedicated top level rule, the ambiguity between decimal literals
     * and the standalone dot can be properly managed.  This is also true of the
     * '-' processing which would be easier and more intuitive in a top level
     * rule, but which needs to be here to resolve ambiguity.
     * <p>
     * In the case of a decimal with no digits on the right side of the decimal
     * point, this is always interpreted as an integer literal AND a subsequent
     * 2nd token of a <code>DOT</code>.  This oddity cannot be easily resolved
     * BUT interestingly enough this is <b>exactly</b> how Progress itself
     * handles this situation AND this is a perfectly valid match since it
     * essentially is an integer.
     * <p>
     * Date literals are generally matched in mm/dd/yyyy or mm-dd-yyyy formats,
     * although the '-' and '/' separators can even be mixed in the same literal
     * (mm-dd/yyyy or mm/dd-yyyy). Both months and days can be specified in 1 or
     * 2 digits (actually this rule matches any number of digits for months).
     * Either separator character can be used, although in Progress one cannot
     * use the '-' between the mm and dd if the constant is being used in an
     * expression.  This lexer has no such limitation.  In Progress the month
     * must be an integer between 1 and 12 but this limit is not implemented
     * here. In Progress the day must be between 1 and the number of days in that
     * month, though this limit is not implemented here. The second separator and
     * the year digits are optional. There can be an optional negative sign
     * preceding any year digits and one can specify a dd and yyyy separator
     * without specifying any year digits at all.  Any number of year digits are
     * valid, though in Progress the year 0 is treated specially, as follows:
     * <ul>
     *    <li> Valid (all resolve to the year 2000)
     *    <ul>
     *       <li> 0
     *       <li> -0
     *       <li> 00
     *    </ul>
     *    <li> Invalid (all complain about specifying the year 0)
     *    <ul>
     *       <li> 000
     *       <li> 0000
     *       <li> 00000 (and so on...)
     *       <li> -00
     *       <li> -000 (and so on...)
     *    </ul>
     * </ul>
     * <p>
     * So y, yy, yyy, yyyy, yyyyy... and -y, -yy, -yyy, -yyyy... all are valid
     * year specifications, except for the specific year zero issue noted above.
     * These limitations on how the year digits work are not implemented here.
     * Over all, this rule supports a superset of the possible date literal
     * formats in Progress and no checking of the values is done.
     * <p>
     * WARNING: at this time there is no support for a quirk of Progress date
     * literals in which constructs like 1/1--- are valid dates equivalent
     * to 01/01/00.
     * <p>
     * This is a top level rule.  The token type defaults to
     * <code>NUM_LITERAL</code> and is overridden by specific actions depending
     * on the scenario matched.
     */
    	public final void mNUM_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = NUM_LITERAL;
    		int _saveIndex;

    		int     ntype = NUM_LITERAL;
    		int     digs  = 0;
    		boolean sign  = false;
    		boolean wasYr = false;

    		{
    		if ((((LA(1) >= '0' && LA(1) <= '9')) && ((LA(2) >= '0' && LA(2) <= '9')) && ((LA(3) >= '0' && LA(3) <= '9')) && ((LA(4) >= '0' && LA(4) <= '9')))&&(
                 (LA(1) >= '0' && LA(1) <= '9')   &&
                 (LA(2) >= '0' && LA(2) <= '9')   &&
                 (LA(3) >= '0' && LA(3) <= '9')   &&
                 (LA(4) >= '0' && LA(4) <= '9')   &&
                 LA(5) == '-'                     &&
                 (LA(6) >= '0' && LA(6) <= '9')   &&
                 (LA(7) >= '0' && LA(7) <= '9')   &&
                 LA(8) == '-'                     &&
                 (LA(9) >= '0' && LA(9) <= '9')   &&
                 (LA(10) >= '0' && LA(10) <= '9') &&
                 (LA(11) == 't' || LA(11) == 'T') &&
                 (LA(12) >= '0' && LA(12) <= '9') &&
                 (LA(13) >= '0' && LA(13) <= '9') &&
                 LA(14) == ':' &&
                 (LA(15) >= '0' && LA(15) <= '9') &&
                 (LA(16) >= '0' && LA(16) <= '9')
               )) {
    			mDIGIT(false);
    			mDIGIT(false);
    			mDIGIT(false);
    			mDIGIT(false);
    			match('-');
    			mDIGIT(false);
    			mDIGIT(false);
    			match('-');
    			mDIGIT(false);
    			mDIGIT(false);
    			match('t');
    			mDIGIT(false);
    			mDIGIT(false);
    			match(':');
    			mDIGIT(false);
    			{
    			if (((LA(1) >= '0' && LA(1) <= '9'))) {
    				mDIGIT(false);
    			}
    			else {
    			}

    			}
    			{
    			if ((LA(1)==':')) {
    				match(':');
    				mDIGIT(false);
    				{
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    				}

    				}
    				{
    				if (((LA(1)=='.'))&&( LA(1) >= '.' && LA(2) >= '0' && LA(2) <= '9' )) {
    					{
    					match('.');
    					{
    					int _cnt1889=0;
    					_loop1889:
    					do {
    						if (((LA(1) >= '0' && LA(1) <= '9'))) {
    							mDIGIT(false);
    						}
    						else {
    							if ( _cnt1889>=1 ) { break _loop1889; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    						}

    						_cnt1889++;
    					} while (true);
    					}
    					}
    				}
    				else {
    				}

    				}
    			}
    			else {
    			}

    			}
    			ntype = DATETIME_LITERAL;
    			{
    			if (((LA(1)=='+'||LA(1)=='-'))&&(
                  (LA(1) == '+' || LA(1) == '-') &&
                  (LA(2) >= '0' && LA(2) <= '9')
                )) {
    				{
    				{
    				switch ( LA(1)) {
    				case '+':
    				{
    					match('+');
    					break;
    				}
    				case '-':
    				{
    					match('-');
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}
    				mDIGIT(false);
    				{
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    				}

    				}
    				{
    				if ((LA(1)==':')) {
    					match(':');
    					mDIGIT(false);
    					{
    					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    						mDIGIT(false);
    					}
    					else {
    					}

    					}
    				}
    				else {
    				}

    				}
    				ntype = DATETIME_TZ_LITERAL;
    				}
    			}
    			else {
    			}

    			}
    		}
    		else if (((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='/'))&&( LA(4) != '*' )) {
    			match("../");
    			{
    			if ((_tokenSet_0.member(LA(1)))) {
    				mSYMBOL(false);
    			}
    			else {
    			}

    			}
    			ntype = FILENAME;
    		}
    		else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='\\')) {
    			match("..\\");
    			{
    			if ((_tokenSet_0.member(LA(1)))) {
    				mSYMBOL(false);
    			}
    			else {
    			}

    			}
    			ntype = FILENAME;
    		}
    		else if ((LA(1)=='.') && ((LA(2) >= '0' && LA(2) <= '9'))) {
    			match('.');
    			{
    			int _cnt1874=0;
    			_loop1874:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					if ( _cnt1874>=1 ) { break _loop1874; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}

    				_cnt1874++;
    			} while (true);
    			}
    			{
    			switch ( LA(1)) {
    			case '-':
    			{
    				match('-');
    				break;
    			}
    			case '+':
    			{
    				_saveIndex=text.length();
    				match('+');
    				text.setLength(_saveIndex);
    				break;
    			}
    			default:
    				{
    				}
    			}
    			}
    			ntype = DEC_LITERAL;
    		}
    		else if (((LA(1)=='.') && (LA(2)=='/'))&&( LA(3) != '*' )) {
    			match("./");
    			{
    			if ((_tokenSet_0.member(LA(1)))) {
    				mSYMBOL(false);
    			}
    			else {
    			}

    			}
    			ntype = FILENAME;
    		}
    		else if ((LA(1)=='.') && (LA(2)=='\\')) {
    			match(".\\");
    			{
    			if ((_tokenSet_0.member(LA(1)))) {
    				mSYMBOL(false);
    			}
    			else {
    			}

    			}
    			ntype = FILENAME;
    		}
    		else if (((LA(1)=='-'||LA(1)=='0') && (LA(2)=='0'||LA(2)=='x') && (true) && (true))&&(
                 (LA(1) == '0' && LA(2) == 'x') ||
                 (LA(1) == '-' && LA(2) == '0' && LA(3) == 'x')
               )) {
    			{
    			switch ( LA(1)) {
    			case '-':
    			{
    				match('-');
    				break;
    			}
    			case '0':
    			{
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			match('0');
    			match('x');
    			ntype = HEX_LITERAL;
    			{
    			_loop1882:
    			do {
    				if ((_tokenSet_10.member(LA(1)))) {
    					mHEX_DIGIT(false);
    				}
    				else {
    					break _loop1882;
    				}

    			} while (true);
    			}
    		}
    		else if ((LA(1)=='+') && ((LA(2) >= '0' && LA(2) <= '9'))) {
    			_saveIndex=text.length();
    			match('+');
    			text.setLength(_saveIndex);
    			{
    			int _cnt1897=0;
    			_loop1897:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					if ( _cnt1897>=1 ) { break _loop1897; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}

    				_cnt1897++;
    			} while (true);
    			}
    			{
    			if (((LA(1)=='.'))&&( (LA(2) >= '0' && LA(2) <= '9') )) {
    				match('.');
    				{
    				int _cnt1900=0;
    				_loop1900:
    				do {
    					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    						mDIGIT(false);
    					}
    					else {
    						if ( _cnt1900>=1 ) { break _loop1900; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    					}

    					_cnt1900++;
    				} while (true);
    				}
    				ntype = DEC_LITERAL;
    			}
    			else {
    			}

    			}
    		}
    		else if ((LA(1)=='.') && (true)) {
    			match('.');
    			ntype = DOT;
    		}
    		else if (((_tokenSet_11.member(LA(1))) && (true) && (true) && (true))&&(
                 (LA(1) >= '0' && LA(1) <= '9') ||
                 (LA(1) == '-' && (LA(2) >= '0' && LA(2) <= '9'))
               )) {
    			{
    			switch ( LA(1)) {
    			case '-':
    			{
    				match('-');
    				sign = true;
    				break;
    			}
    			case '0':  case '1':  case '2':  case '3':
    			case '4':  case '5':  case '6':  case '7':
    			case '8':  case '9':
    			{
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			int _cnt1903=0;
    			_loop1903:
    			do {
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    					if ( _cnt1903>=1 ) { break _loop1903; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    				}

    				_cnt1903++;
    			} while (true);
    			}
    			{
    			if (((LA(1)=='-'||LA(1)=='/') && ((LA(2) >= '0' && LA(2) <= '9')))&&( (LA(2) >= '0' && LA(2) <= '9') )) {
    				{
    				switch ( LA(1)) {
    				case '/':
    				{
    					match('/');
    					break;
    				}
    				case '-':
    				{
    					match('-');
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}
    				mDIGIT(false);
    				{
    				if (((LA(1) >= '0' && LA(1) <= '9'))) {
    					mDIGIT(false);
    				}
    				else {
    				}

    				}
    				{
    				if (((LA(1)=='-'||LA(1)=='/') && (LA(2)=='.'||LA(2)=='/'))&&( LA(1) != '-' || LA(2) == '/' )) {
    					mMONTH_TRASH_MODE(false);
    				}
    				else if ((((LA(1) >= '-' && LA(1) <= '/')) && (true))&&(
                            LA(1) != '.' ||
                            (LA(2) == '-' || (LA(2) >= '0' && LA(2) <= '9'))
                         )) {
    					{
    					switch ( LA(1)) {
    					case '/':
    					{
    						match('/');
    						break;
    					}
    					case '-':
    					{
    						match('-');
    						break;
    					}
    					case '.':
    					{
    						match('.');
    						break;
    					}
    					default:
    					{
    						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    					}
    					}
    					}
    					{
    					if ((LA(1)=='-')) {
    						match('-');
    					}
    					else {
    					}

    					}
    					{
    					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    						{
    						int _cnt1922=0;
    						_loop1922:
    						do {
    							if (((LA(1) >= '0' && LA(1) <= '9'))) {
    								mDIGIT(false);
    								ntype = DATE_LITERAL;
    							}
    							else {
    								if ( _cnt1922>=1 ) { break _loop1922; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    							}

    							_cnt1922++;
    						} while (true);
    						}
    						{
    						if ((LA(1)=='-'||LA(1)=='/')) {
    							mYEAR_TRASH_MODE(false);
    						}
    						else {
    						}

    						}
    					}
    					else {
    					}

    					}
    				}
    				else {
    				}

    				}
    				ntype = DATE_LITERAL;
    			}
    			else if (((LA(1)=='.'))&&( (LA(2) >= '0' && LA(2) <= '9') )) {
    				match('.');
    				{
    				int _cnt1906=0;
    				_loop1906:
    				do {
    					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    						mDIGIT(false);
    						digs++;
    					}
    					else {
    						if ( _cnt1906>=1 ) { break _loop1906; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    					}

    					_cnt1906++;
    				} while (true);
    				}
    				ntype = DEC_LITERAL;
    				{
    				if (((LA(1)=='-'||LA(1)=='/') && (LA(2)=='.'||LA(2)=='/'))&&( LA(1) != '-' || LA(2) == '/' )) {
    					mMONTH_TRASH_MODE(false);
    					ntype = DATE_LITERAL;
    				}
    				else if ((((LA(1) >= '-' && LA(1) <= '/')) && (true) && (true) && (true))&&(
                            digs < 3 &&
                            (LA(1) != '.' ||
                             (LA(2) == '-' || (LA(2) >= '0' && LA(2) <= '9')))
                         )) {
    					{
    					switch ( LA(1)) {
    					case '/':
    					{
    						match('/');
    						ntype = DATE_LITERAL;
    						break;
    					}
    					case '-':
    					{
    						match('-');
    						ntype = DEC_LITERAL;
    						break;
    					}
    					case '.':
    					{
    						match('.');
    						ntype = DATE_LITERAL;
    						break;
    					}
    					default:
    					{
    						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    					}
    					}
    					}
    					{
    					if ((LA(1)=='-')) {
    						match('-');
    					}
    					else {
    					}

    					}
    					{
    					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    						{
    						int _cnt1912=0;
    						_loop1912:
    						do {
    							if (((LA(1) >= '0' && LA(1) <= '9'))) {
    								mDIGIT(false);
    								ntype = DATE_LITERAL;
    							}
    							else {
    								if ( _cnt1912>=1 ) { break _loop1912; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    							}

    							_cnt1912++;
    						} while (true);
    						}
    						{
    						if ((LA(1)=='-'||LA(1)=='/')) {
    							mYEAR_TRASH_MODE(false);
    						}
    						else {
    						}

    						}
    					}
    					else {
    					}

    					}
    				}
    				else if ((LA(1)=='+'||LA(1)=='-') && (true) && (true) && (true)) {
    					{
    					switch ( LA(1)) {
    					case '-':
    					{
    						match('-');
    						break;
    					}
    					case '+':
    					{
    						match('+');
    						break;
    					}
    					default:
    					{
    						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    					}
    					}
    					}
    				}
    				else {
    				}

    				}
    			}
    			else if (((LA(1)=='+'||LA(1)=='-') && (true))&&( !sign )) {
    				{
    				switch ( LA(1)) {
    				case '-':
    				{
    					match('-');
    					break;
    				}
    				case '+':
    				{
    					match('+');
    					break;
    				}
    				default:
    				{
    					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    				}
    				}
    				}
    			}
    			else {
    			}

    			}
    		}
    		else if ((LA(1)=='+'||LA(1)=='-') && (true) && (true) && (true)) {
    			{
    			switch ( LA(1)) {
    			case '-':
    			{
    				match('-');
    				ntype = MINUS;
    				break;
    			}
    			case '+':
    			{
    				match('+');
    				ntype = PLUS;
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    			}
    			}
    			}
    			{
    			if (((LA(1)=='.'))&&( (LA(2) >= '0' && LA(2) <= '9') )) {
    				match('.');
    				{
    				int _cnt1928=0;
    				_loop1928:
    				do {
    					if (((LA(1) >= '0' && LA(1) <= '9'))) {
    						mDIGIT(false);
    					}
    					else {
    						if ( _cnt1928>=1 ) { break _loop1928; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    					}

    					_cnt1928++;
    				} while (true);
    				}
    				ntype = DEC_LITERAL;
    			}
    			else if (((LA(1)=='-'))&&( ntype == MINUS )) {
    				{
    				int _cnt1930=0;
    				_loop1930:
    				do {
    					if ((LA(1)=='-')) {
    						match('-');
    					}
    					else {
    						if ( _cnt1930>=1 ) { break _loop1930; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    					}

    					_cnt1930++;
    				} while (true);
    				}
    				ntype = UNQUOTED_TEXT;
    			}
    			else if (((LA(1)=='+'))&&( ntype == PLUS )) {
    				{
    				int _cnt1932=0;
    				_loop1932:
    				do {
    					if ((LA(1)=='+')) {
    						match('+');
    					}
    					else {
    						if ( _cnt1932>=1 ) { break _loop1932; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
    					}

    					_cnt1932++;
    				} while (true);
    				}
    				ntype = UNQUOTED_TEXT;
    			}
    			else {
    			}

    			}
    		}
    		else {
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}

    		}

    		// post-processing for hex literals
    		if (ntype == HEX_LITERAL)
    		{
    		String hex = getText();
    		int    min = (hex.charAt(0) == '-') ? 3 : 2;
    		int    len = hex.length();

    		// special case where the x is ignored, the result is the same as num_literal == 0
    		if (len == min)
    		{
    		setText("0");
    		ntype = NUM_LITERAL;
    		}

    		// too large, this is invalid 4GL code
    		if (len > (min + 16))
    		{
    		// TODO: do something here to raise an error
    		}
    		}

    		// this is a case where we can't drop the '+' until after we know it
    		// is part of a decimal literal, since it might just be a plus sign
    		if (ntype == DEC_LITERAL)
    		{
    		String txt = getText();

    		if (txt.charAt(0) == '+')
    		{
    		// get rid of the useless unary plus
    		setText(txt.substring(1));
    		}
    		}

    		_ttype = ntype;

    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches any numeric digit: <code>0 - 9</code>.
     */
    	protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = DIGIT;
    		int _saveIndex;

    		matchRange('0','9');
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches any single character that can match a hexadecimal digit. Internally, it uses the
     * <code>LETTER</code> and <code>DIGIT</code> rules. This is simply a helper rule to make
     * references easier.
     */
    	protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = HEX_DIGIT;
    		int _saveIndex;

    		switch ( LA(1)) {
    		case 'a':  case 'b':  case 'c':  case 'd':
    		case 'e':  case 'f':
    		{
    			matchRange('a','f');
    			break;
    		}
    		case '0':  case '1':  case '2':  case '3':
    		case '4':  case '5':  case '6':  case '7':
    		case '8':  case '9':
    		{
    			mDIGIT(false);
    			break;
    		}
    		default:
    		{
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Trash (of arbitrary length) that can be matched after the month at the end of a date literal.
     */
    	protected final void mMONTH_TRASH_MODE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = MONTH_TRASH_MODE;
    		int _saveIndex;

    		{
    		if ((LA(1)=='/') && (LA(2)=='/')) {
    			match("//");
    		}
    		else if ((LA(1)=='/') && (LA(2)=='.')) {
    			match("/.");
    		}
    		else if ((LA(1)=='-')) {
    			match("-/");
    		}
    		else {
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}

    		}
    		{
    		_loop1993:
    		do {
    			switch ( LA(1)) {
    			case '0':  case '1':  case '2':  case '3':
    			case '4':  case '5':  case '6':  case '7':
    			case '8':  case '9':
    			{
    				mDIGIT(false);
    				break;
    			}
    			case '/':
    			{
    				match('/');
    				break;
    			}
    			case '-':
    			{
    				match('-');
    				break;
    			}
    			default:
    				if (((LA(1)=='.'))&&( LA(2) >= '0' && LA(2) <= '9' )) {
    					match('.');
    				}
    			else {
    				break _loop1993;
    			}
    			}
    		} while (true);
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Trash (of arbitrary length) that can be matched after a valid year at the end of a date literal.
     */
    	protected final void mYEAR_TRASH_MODE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = YEAR_TRASH_MODE;
    		int _saveIndex;

    		{
    		switch ( LA(1)) {
    		case '/':
    		{
    			match("/");
    			break;
    		}
    		case '-':
    		{
    			match("-");
    			break;
    		}
    		default:
    		{
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		}
    		{
    		_loop1997:
    		do {
    			switch ( LA(1)) {
    			case '0':  case '1':  case '2':  case '3':
    			case '4':  case '5':  case '6':  case '7':
    			case '8':  case '9':
    			{
    				mDIGIT(false);
    				break;
    			}
    			case '/':
    			{
    				match('/');
    				break;
    			}
    			case '-':
    			{
    				match('-');
    				break;
    			}
    			default:
    				if (((LA(1)=='.'))&&( LA(2) >= '0' && LA(2) <= '9' )) {
    					match('.');
    				}
    			else {
    				break _loop1997;
    			}
    			}
    		} while (true);
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches other unexpected characters and generates a token rather than throwing an exception
     * (this rule must be changed when matched characters are moved to another top level rule).  Note
     * that this rule is designed to match the unusual characters that can't be normally used in a
     * Progress 4GL source program, but might appear in a command token list for a shell command that
     * is embedded in a procedure. These characters can also be seen in malformed symbols
     * (e.g. frame/stream/query... names), but not in regular symbols (var and field names). Likewise
     * the other control characters (other than whitespace) are not matched. The list of matched
     * characters:
     * <p>
     * <pre>
     * '`'
     * '!'
     * '#'
     * '$'
     * '%'
     * '&amp;'
     * '{'
     * '}'
     * '|'
     * ';'
     * '\u0080' through '\ufffe' (all UNICODE characters starting in the extended ASCII range and above)
     * </pre>
     * <p>
     * Anything that is not matched here will still trigger an exception. Note that ANTLR's filter
     * feature seems to be a better approach to resolve this problem (of wanting to generate an
     * <code>UNKNOWN_TOKEN</code> rather than throw an exception), however it can only handle the
     * consumption of such characters.  The filter rule that is called when there is no top level
     * match cannot generate tokens because of the way that <code>nextToken</code> is generated by
     * ANTLR.  Such filters are not allowed to generate a token so this less-optimal approach of
     * specifying the special characters in advance is the result.
     */
    	public final void mUNKNOWN_TOKEN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = UNKNOWN_TOKEN;
    		int _saveIndex;

    		switch ( LA(1)) {
    		case '`':
    		{
    			match('`');
    			break;
    		}
    		case '!':
    		{
    			match('!');
    			break;
    		}
    		case '#':
    		{
    			match('#');
    			break;
    		}
    		case '$':
    		{
    			match('$');
    			break;
    		}
    		case '%':
    		{
    			match('%');
    			break;
    		}
    		case '&':
    		{
    			match('&');
    			break;
    		}
    		case '{':
    		{
    			match('{');
    			break;
    		}
    		case '}':
    		{
    			match('}');
    			break;
    		}
    		case '|':
    		{
    			match('|');
    			break;
    		}
    		case ';':
    		{
    			match(';');
    			break;
    		}
    		default:
    			if (((LA(1) >= '\u0080' && LA(1) <= '\ufffe'))) {
    				matchRange('\u0080','\ufffe');
    			}
    		else {
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    /**
     * Matches all characters that can be made part of a valid user-defined
     * symbol (except alphabetic and numeric characters):
     * <code> # $ % &amp; - _ </code>
     */
    	protected final void mSYM_CHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
    		int _ttype; Token _token=null; int _begin=text.length();
    		_ttype = SYM_CHAR;
    		int _saveIndex;

    		switch ( LA(1)) {
    		case '#':
    		{
    			match('#');
    			break;
    		}
    		case '$':
    		{
    			match('$');
    			break;
    		}
    		case '%':
    		{
    			match('%');
    			break;
    		}
    		case '&':
    		{
    			match('&');
    			break;
    		}
    		case '-':
    		{
    			match('-');
    			break;
    		}
    		case '_':
    		{
    			match('_');
    			break;
    		}
    		default:
    		{
    			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
    		}
    		}
    		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
    			_token = makeToken(_ttype);
    			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
    		}
    		_returnToken = _token;
    	}

    	private static final long[] mk_tokenSet_0() {
    		long[] data = new long[1025];
    		data[0]=140737488355328L;
    		data[1]=576460746129408000L;
    		return data;
    	}
    	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
    	private static final long[] mk_tokenSet_1() {
    		long[] data = new long[1025];
    		data[0]=288063250384289792L;
    		return data;
    	}
    	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
    	private static final long[] mk_tokenSet_2() {
    		long[] data = new long[3072];
    		data[0]=576461276289433600L;
    		data[1]=4035225270418931712L;
    		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
    		data[1023]=9223372036854775807L;
    		return data;
    	}
    	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
    	private static final long[] mk_tokenSet_3() {
    		long[] data = new long[2048];
    		data[0]=-17179869185L;
    		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    		data[1023]=9223372036854775807L;
    		return data;
    	}
    	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
    	private static final long[] mk_tokenSet_4() {
    		long[] data = new long[2048];
    		data[0]=-17179870209L;
    		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    		data[1023]=9223372036854775807L;
    		return data;
    	}
    	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
    	private static final long[] mk_tokenSet_5() {
    		long[] data = new long[2048];
    		data[0]=-549755823105L;
    		data[1]=-4611686018695823361L;
    		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
    		data[1023]=9223372036854775807L;
    		return data;
    	}
    	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
    	private static final long[] mk_tokenSet_6() {
    		long[] data = new long[2048];
    		data[0]=-17179878401L;
    		data[1]=-4611686018695823361L;
    		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
    		data[1023]=9223372036854775807L;
    		return data;
    	}
    	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
    	private static final long[] mk_tokenSet_7() {
    		long[] data = new long[1025];
    		data[1]=5647126079995904L;
    		return data;
    	}
    	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
    	private static final long[] mk_tokenSet_8() {
    		long[] data = new long[1025];
    		data[0]=287984600943165440L;
    		data[1]=576460745860972544L;
    		return data;
    	}
    	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
    	private static final long[] mk_tokenSet_9() {
    		long[] data = new long[2048];
    		data[0]=-9217L;
    		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
    		data[1023]=9223372036854775807L;
    		return data;
    	}
    	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
    	private static final long[] mk_tokenSet_10() {
    		long[] data = new long[1025];
    		data[0]=287948901175001088L;
    		data[1]=541165879296L;
    		return data;
    	}
    	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
    	private static final long[] mk_tokenSet_11() {
    		long[] data = new long[1025];
    		data[0]=287984085547089920L;
    		return data;
    	}
    	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());

    	}