# SchemaParser.java

    // $ANTLR 2.7.7 (20060906): "schema.g" -> "SchemaParser.java"$

    /*
    ** Module   : SchemaParser.java
    **            SchemaParserTokenTypes.java
    ** Abstract : Progress database schema dump file (.df) parser
    **
    ** Copyright (c) 2004-2022, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- --JPRM-- ----------------------------Description-----------------------------
    ** 001 ECF 20041130   @18769 WARNING, THIS IS A GENERATED FILE!!! DO NOT EDIT THIS FILE. The
    **                           original source file is schema.g!
    */

    package com.goldencode.p2j.schema;

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

    import antlr.TokenBuffer;
    import antlr.TokenStreamException;
    import antlr.TokenStreamIOException;
    import antlr.ANTLRException;
    import antlr.LLkParser;
    import antlr.Token;
    import antlr.TokenStream;
    import antlr.RecognitionException;
    import antlr.NoViableAltException;
    import antlr.MismatchedTokenException;
    import antlr.SemanticException;
    import antlr.ParserSharedInputState;
    import antlr.collections.impl.BitSet;
    import antlr.collections.AST;
    import java.util.Hashtable;
    import antlr.ASTFactory;
    import antlr.ASTPair;
    import antlr.collections.impl.ASTArray;

    /**
     * Parser for a token stream generated by the <code>ProgressLexer</code>,
     * as part of the process of interpreting Progress schema dump (<code>*.df
     * </code>) files. Builds a normalized AST meant to be compatible in areas
     * which have similar options and structures as the AST created by the
     * <code>ProgressParser</code> from Progress 4GL source code.
     * <p>
     * <strong>NOTE:</strong>
     * DO NOT MAKE MODIFICATIONS TO THE SOURCE FILE FOR THIS CLASS DIRECTLY.
     * This class is generated by ANTLR, using the <code>schema.g</code> grammar.
     * All changes must be made at the grammar level.
     */
    public class SchemaParser extends antlr.LLkParser       implements SchemaParserTokenTypes
     {

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

       /** Name of the specialized AST class to use when parsing */
       public static final Class AST_CLASS = ProgressAst.class;

       /** Remember our platform so that we can properly parse strings containing escapes. */
       private static final boolean unixEsc = Configuration.getParameter("unix-escapes", true);

       /** Track the name of the table currently being parsed */
       private String currentTable = null;

       /** Filter implementation to allow access to hidden tokens */
       private TokenStreamHiddenTokenFilter hidden = null;

       /**
        * Constructs a parser using a lexer instance.
        *
        * @param    lexer
        *           An instance of a <code>TokenStream</code> object.
        * @param    bogus
        *           Useless parameter which is only here to differentiate between
        *           this constructor and the standard one that ANTLR generates
        *           which doesn't have this parameter.
        */
       public SchemaParser(TokenStream lexer, boolean bogus)
       {
          // init our parent class
          this(lexer, 2);

          // shift into filter mode
          hidden = new TokenStreamHiddenTokenFilter(lexer);
          setTokenBuffer(new TokenBuffer(hidden));

          // setup the lexer
          ((ProgressLexer)lexer).setUnixEscapes(unixEsc);
          ((ProgressLexer)lexer).activateHiddenProcessing();
          setupHiddenFilter();
       }

       /**
        * Calculate the signature string for a field.
        *
        * @param    type
        *           The field's data type.
        * @param    extent
        *           The extent size (as a num literal) or {@code null} if the field is scalar.
        *
        * @return   The signature in "datatype" or "datatype[extent]" format.
        */
       public static String fieldSignature(int type, String extent)
       {
          String code = null;

          switch (type)
          {
             case FIELD_BLOB:
                code = "blob";
                break;
             case FIELD_CHAR:
                code = "char";
                break;
             case FIELD_CLOB:
                code = "clob";
                break;
             case FIELD_COM_HANDLE:
                code = "comh";
                break;
             case FIELD_DATE:
                code = "date";
                break;
             case FIELD_DATETIME:
                code = "dt";
                break;
             case FIELD_DATETIME_TZ:
                code = "dttz";
                break;
             case FIELD_DEC:
                code = "dec";
                break;
             case FIELD_INT:
                code = "int";
                break;
             case FIELD_INT64:
                code = "i64";
                break;
             case FIELD_LOGICAL:
                code = "log";
                break;
             case FIELD_RECID:
                code = "rec";
                break;
             case FIELD_ROWID:
                code = "row";
                break;
             case FIELD_RAW:
                code = "raw";
                break;
             case FIELD_HANDLE:
                code = "hndl";
                break;
             case FIELD_BIGINT:
                code = "bigi";
                break;
             case FIELD_BYTE:
                code = "byte";
                break;
             case FIELD_DOUBLE:
                code = "dbl";
                break;
             case FIELD_FIXCHAR:
                code = "fixc";
                break;
             case FIELD_FLOAT:
                code = "flt";
                break;
             case FIELD_SHORT:
                code = "shrt";
                break;
             case FIELD_TIMESTAMP:
                code = "tmst";
                break;
             case FIELD_TIME:
                code = "time";
                break;
             default:
                code = "unkw";
                break;
          }

          return (extent == null) ? code : code + "[" + extent + "]";
       }

       /**
        * Configure the hidden filter to ensure that token types that are not
        * normally recognized by the parser, are hidden (but still accessible)
        * using the filter.
        */
       private void setupHiddenFilter()
       {
          hidden.hide(WS);
          hidden.hide(TILDE);
          hidden.hide(COMMENT);
          hidden.hide(BACKSLASH);
       }

       /**
        * Helper to output a warning message with AST-specific type, line and
        * column data to STDERR.
        *
        * @param    node
        *           The AST to inspect for log data.
        * @param    front
        *           Log prefix.
        * @param    back
        *           Log suffix.
        */
       private void outputWarning(Aast node, String front, String back)
       {
          LOG.log(Level.WARNING, front +
                             node.getText() +
                             " [" +
                             node.getLine() +
                             ":" +
                             node.getColumn() +
                             "]" +
                             back);
       }

       /**
        * Helper to remove surrounding unnecessary double quotes. This method
        * assumes that there *are* double quotes as the first and last chars.
        */
       private String removeBogusQuotes(String quoted)
       {
          if (quoted == null)
             return "";

          return quoted.substring(1, quoted.length() - 1);
       }

       /**
        * Set the line and column numbers of the target AST to be the same as
        * the source AST.
        *
        * @param    source
        *           AST with the line and column numbers to copy.
        * @param    target
        *           AST to modify.
        */
       private void forceLineColumnNums(Aast source, Aast target)
       {
          target.setLine(source.getLine());
          target.setColumn(source.getColumn());
       }

       /**
        * Helper to instantiate a new (limited use) lexer and re-lex the input.
        * The problem is that the schema dump file puts everything inside quotes
        * and the lexer doesn't know when to remove the quotes and when to leave
        * them.  This results in the <code>INITIAL</code> having children that
        * are of the <code>STRING</code> type even when they should be some other
        * kind of literal.  <b>This method removes the unnecessary enclosing
        * double quotes and then calls the lexer to obtain the resulting token.
        * It is assumed at this time that only one token will be present in the
        * passed input string.  If this is not the case, we will have to make
        * more serious changes!</b>
        *
        * @param    input
        *           The double quoted enclosed string containing a token to lex.
        *
        * @return   The token of the proper token type and text OR
        *           <code>null</code> if the input text is an empty string.
        */
       private Token relex(String input)
       throws antlr.TokenStreamException
       {
          String cleaner = removeBogusQuotes(input);

          if ("".equals(cleaner))
          {
             return null;
          }

          // Create a SymbolResolver with options that bypass symbol dictionary init
          // schema=false, case sense=true, propath=null, silent=true, dict=false RFB20190912
          SymbolResolver sr = new SymbolResolver(false, true, null, true, false, null);

          // disable the dot kludge as the following DOT will sometimes break
          // lexing, this needs to be a single token only
          ProgressLexer relex = new ProgressLexer(new StringReader(cleaner), sr, false);

          return relex.nextToken();
       }

       /**
        * Check if the given token is prefaced by whitespace in the original
        * source code (by reading from the hidden token stream).
        *
        * @param    tok
        *           The token from the token stream (the lexer) which is needed
        *           in order to examine any prefacing hidden tokens.
        *
        * @return   <code>true</code> if the given token is prefaced by whitespace
        *           in the hidden token stream.
        */
       private boolean prefacedByWhitespace(Token tok)
       {
          CommonHiddenStreamToken space = null;
          space = hidden.getHiddenBefore((CommonHiddenStreamToken) tok);

          return (space != null && space.getType() == WS);
       }

       /**
        * Check if the given token is followed by whitespace in the original
        * source code (by reading from the hidden token stream).
        *
        * @param    tok
        *           The token from the token stream (the lexer) which is needed
        *           in order to examine if there are following hidden tokens.
        *
        * @return   <code>true</code> if the given token is followed by whitespace
        *           in the hidden token stream.
        */
       private boolean followedByWhitespace(Token tok)
       {
          CommonHiddenStreamToken space = null;
          space = hidden.getHiddenAfter((CommonHiddenStreamToken) tok);

          return (space != null && space.getType() == WS);
       }

       /**
        * Merge the following non-hidden token text until (and including) a token
        * followed by whitespace or <code>EOF</code>.
        * <p>
        * All the merged tokens will be consumed and the merged text will be stored
        * in the last token before the token that triggered the end of merging. The
        * line and column numbers of the merged token will be forced to the same
        * values as the first token on entry.
        *
        * @return   <code>true</code> if merging was done, <code>false</code> if
        *           no changes were made.
        */
       private boolean mergeUntilWS()
       throws TokenStreamException,
              MismatchedTokenException
       {
          boolean merged = false;

          CommonToken current = (CommonToken) LT(1);
          CommonToken next    = (CommonToken) LT(2);

          int line = current.getLine();
          int col  = current.getColumn();

          StringBuilder sb = new StringBuilder();

          while (!followedByWhitespace(current)  && !(next != null && next.getType() == EOF))
          {
             merged = true;

             // save the text of the current token
             sb.append(current.getText());

             matchNot(EOF);

             // update the state for next iteration
             current = next;
             next    = (CommonToken) LT(2);
          }

          if (merged)
          {
             // put the last text into the buffer
             sb.append(current.getText());

             // override the last token's contents and positioning with the
             // merged results
             current.setText(sb.toString());
             current.setLine(line);
             current.setColumn(col);

             // we don't match here, so that the calling code can match on the
             // resulting token
          }

          return merged;
       }

       /**
        * Provides a command line interface for an end user to drive and/or test
        * schema file lexing.
        * <p>
        * Syntax:
        * <pre>
        *    java SchemaParser [-l | -v] &lt;schema_dump_file&gt;
        * </pre>
        * Where:
        * <ul>
        *   <li> -l specifies to only run the lexer rather than the full parser
        *   <li> -v specifies to display the parsed tree in a Swing GUI panel
        *   <li> &lt;schema_dump_file&gt; is the filename of the schema dump
        *        (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 )
       {
          if (args.length == 0)
          {
             LOG.log(Level.SEVERE, "Syntax: java.exe SchemaParser [-l | -v] " +
                                "<schema_dump_file>");
             System.exit( -1 );
          }

          try
          {
             // we know there is at least 1 arg
             boolean lexonly = "-l".equals(args[0]);
             boolean visual  = "-v".equals(args[0]);

             String fname = args[0];

             if (lexonly || visual)
             {
                fname = args[1];
             }

             // setup
             SymbolResolver sym = new SymbolResolver(false);
             FileReader     fr  = new FileReader(fname);
             BufferedReader br  = new BufferedReader(fr);

             if (lexonly)
             {
                // lex only
                LexerDumpFilter test = new LexerDumpFilter(br, sym);
                test.activateSchemaProcessing();
                test.setOutput(new PrintWriter(System.out));

                // start the lexing and print a record for each token
                test.dump();
             }
             else
             {
                ProgressLexer lexer = new ProgressLexer(br, sym);
                lexer.activateSchemaProcessing();

                SchemaParser parser = new SchemaParser(lexer, true);

                // parse it and create a tree
                parser.schema();

                AnnotatedAst result = (AnnotatedAst) parser.getAST();

                // this is needed to ensure the parents are set right, or DumpTree
                // will be unable to calculate indents AND features like the
                // Aast.iterator() will also fail to operate properly
                result.fixups((Aast) null, null);

                // print a report to stdout
                DumpTree visitor = new DumpTree();
                visitor.visit(result);

                if (visual)
                {
                   // display the tree in a frame window if debug is on
                   ASTFrame frame = new ASTFrame("Database Schema", result);
                   frame.setVisible(true);
                }
             }
          }

          catch( Exception excpt )
          {
             LOG.log(Level.SEVERE, "", excpt);
          }
       }

    protected SchemaParser(TokenBuffer tokenBuf, int k) {
      super(tokenBuf,k);
      tokenNames = _tokenNames;
      buildTokenTypeASTClassMap();
      astFactory = new ASTFactory(getTokenTypeToASTClassMap());
    }

    public SchemaParser(TokenBuffer tokenBuf) {
      this(tokenBuf,2);
    }

    protected SchemaParser(TokenStream lexer, int k) {
      super(lexer,k);
      tokenNames = _tokenNames;
      buildTokenTypeASTClassMap();
      astFactory = new ASTFactory(getTokenTypeToASTClassMap());
    }

    public SchemaParser(TokenStream lexer) {
      this(lexer,2);
    }

    public SchemaParser(ParserSharedInputState state) {
      super(state,2);
      tokenNames = _tokenNames;
      buildTokenTypeASTClassMap();
      astFactory = new ASTFactory(getTokenTypeToASTClassMap());
    }

    /**
     * Top-level parser method, from which the entire recursive descent parsing
     * of tokens for this file begins. This rule expects to match, in order:
     * <ol>
     * <li> zero or one {@link #database} construct;
     * <li> zero or more {@link #sequence} constructs;
     * <li> zero or more {@link #table} constructs;
     * <li> one {@link #trailer} construct;
     * </ol>
     * <p>
     * The root of the schema AST will be an artificial <code>DATABASE</code> node.
     * All sub-trees created by the rule references will be attached as child
     * nodes, in the order shown above.
     */
    	public final void schema() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast schema_AST = null;
    		Aast u_AST = null;

    		try {      // for error handling

    			astFactory.setASTNodeClass(AST_CLASS);
    			astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(DATABASE));
    			String name = null;

    			{
    			{
    			if ((LA(1)==KW_ADD||LA(1)==KW_UPDATE) && (LA(2)==KW_DATABASE)) {
    				name=database();
    				schema_AST = (Aast)currentAST.root;

    				if (name != null) schema_AST.setText(name);
    				schema_AST.setLine(1);
    				schema_AST.setColumn(1);

    			}
    			else if ((LA(1)==DOT||LA(1)==KW_ADD||LA(1)==KW_UPDATE) && (_tokenSet_0.member(LA(2)))) {
    			}
    			else {
    				throw new NoViableAltException(LT(1), getFilename());
    			}

    			}
    			{
    			_loop5:
    			do {
    				if ((LA(1)==KW_ADD) && (LA(2)==KW_SEQUENCE)) {
    					sequence();
    					astFactory.addASTChild(currentAST, returnAST);
    				}
    				else if ((LA(1)==KW_ADD) && (LA(2)==KW_TABLE)) {
    					table();
    					astFactory.addASTChild(currentAST, returnAST);
    				}
    				else {
    					break _loop5;
    				}

    			} while (true);
    			}
    			{
    			_loop7:
    			do {
    				if ((LA(1)==KW_UPDATE)) {
    					update_stuff();
    					u_AST = (Aast)returnAST;

    					outputWarning(u_AST, "WARNING: ignoring cruft ", "");

    				}
    				else {
    					break _loop7;
    				}

    			} while (true);
    			}
    			trailer();
    			}
    			schema_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_1);
    		}
    		returnAST = schema_AST;
    	}

    /**
     * Match a database construct, which specifies the database name. Curiously,
     * the database name seems to always show up as unknown (&quot;?&quot;).
     * <p>
     * The sub-tree created by this rule is rooted at the <code>KW_DATABASE</code>
     * node and has a single child which is the <code>STRING</code> that is the
     * database name. Any <code>KW_ADD</code> or <code>KW_UPDATE</code> token
     * is dropped.
     *
     * @return   The text name of the database.
     */
    	public final String  database() throws RecognitionException, TokenStreamException {
    		String name = null;

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast database_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			{
    			switch ( LA(1)) {
    			case KW_ADD:
    			{
    				match(KW_ADD);
    				break;
    			}
    			case KW_UPDATE:
    			{
    				match(KW_UPDATE);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			Aast tmp3_AST = null;
    			tmp3_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp3_AST);
    			match(KW_DATABASE);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.addASTChild(currentAST, s_AST);
    			match(STRING);
    			name = removeBogusQuotes(s_AST.getText());
    			database_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_2);
    		}
    		returnAST = database_AST;
    		return name;
    	}

    /**
     * Matches a sequence definition, which consists of the
     * <code>ADD SEQUENCE</code> phrase followed by sequence property
     * definitions.
     * <p>
     * The AST is produced rooted at the artificial <code>SEQUENCE</code> node.
     * The <code>KW_ADD</code>, <code>KW_SEQUENCE</code> and the <code>STRING</code>
     * tokens are all dropped from the tree, and sequence name (from the
     * <code>STRING</code> node) will be set as the text for the
     * <code>SEQUENCE</code> node.  The children of this node will be the sub-trees
     * created by the rule references for the sequence properties.
     */
    	public final void sequence() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast sequence_AST = null;
    		Token  seq = null;
    		Aast seq_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(SEQUENCE));
    			{
    			match(KW_ADD);
    			seq = LT(1);
    			seq_AST = (Aast)astFactory.create(seq);
    			match(KW_SEQUENCE);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			match(STRING);
    			sequence_AST = (Aast)currentAST.root;
    			sequence_AST.setText(removeBogusQuotes(s_AST.getText()));
    			{
    			_loop21:
    			do {
    				switch ( LA(1)) {
    				case KW_INIT:
    				{
    					initial(FIELD_INT, null);
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_INCR:
    				{
    					increment();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CYCLE:
    				{
    					cycleOnLimit();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_MIN_VAL:
    				{
    					minVal();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_MAX_VAL:
    				{
    					maxVal();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_MULTI_TN:
    				{
    					multitenant();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				default:
    				{
    					break _loop21;
    				}
    				}
    			} while (true);
    			}
    			}
    			sequence_AST = (Aast)currentAST.root;

    			forceLineColumnNums(seq_AST, sequence_AST);

    			sequence_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_2);
    		}
    		returnAST = sequence_AST;
    	}

    /**
     * Matches a table definition, which consists of the <code>ADD TABLE</code>
     * phrase followed by table property definitions, some of which are optional,
     * then some number of {@link #field} and/or {@link #index} definitions.
     * <p>
     * The AST is produced rooted at an artificial <code>TABLE</code> node (not to
     * be confused with the <code>KW_TABLE</code>).  The <code>KW_ADD</code>,
     * <code>KW_TABLE</code>, <code>STRING</code>, <code>KW_TYPE</code> and
     * <code>SYMBOL</code> tokens are all dropped from the tree, and table name
     * (from the <code>STRING</code> node) will be set as the text for the
     * <code>TABLE</code> node.  The children of this node will be the sub-trees
     * created by the rule references for the table properties, fields and indexes.
     */
    	public final void table() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast table_AST = null;
    		Token  tab = null;
    		Aast tab_AST = null;
    		Token  s = null;
    		Aast s_AST = null;
    		Token  y = null;
    		Aast y_AST = null;
    		Token  d = null;
    		Aast d_AST = null;

    		try {      // for error handling

    			astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(TABLE));
    			String signature = "";
    			String fsig = null;
    			String isig = null;
    			Map<String, Integer> fields = new HashMap<>();
    			Map<String, Integer> fieldTypes = new HashMap<>();
    			int idx = 0;

    			{
    			match(KW_ADD);
    			tab = LT(1);
    			tab_AST = (Aast)astFactory.create(tab);
    			match(KW_TABLE);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			match(STRING);
    			{
    			switch ( LA(1)) {
    			case KW_TYPE:
    			{
    				y = LT(1);
    				y_AST = (Aast)astFactory.create(y);
    				match(KW_TYPE);
    				d = LT(1);
    				d_AST = (Aast)astFactory.create(d);
    				match(SYMBOL);
    				break;
    			}
    			case DOT:
    			case KW_AREA:
    			case KW_CATEGORY:
    			case KW_DMP_NAME:
    			case KW_FROZEN:
    			case KW_LABEL_SA:
    			case KW_MULTI_TN:
    			case KW_NO_DEFAR:
    			case KW_TAB_TRG:
    			case KW_VALEXP:
    			case KW_VALMSG:
    			case KW_VALMG_SA:
    			case KW_ADD:
    			case KW_LABEL:
    			case KW_UPDATE:
    			case KW_CAN_CREA:
    			case KW_CAN_DEL:
    			case KW_CAN_DUMP:
    			case KW_CAN_LOAD:
    			case KW_CAN_READ:
    			case KW_CAN_WRT:
    			case KW_DESCR:
    			case KW_HIDDEN:
    			case SYMBOL:
    			{
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			table_AST = (Aast)currentAST.root;

    			currentTable = removeBogusQuotes(s_AST.getText());
    			table_AST.putAnnotation("legacy_name", currentTable);
    			table_AST.putAnnotation("historical", currentTable);
    			currentTable = currentTable.toLowerCase();
    			table_AST.setText(currentTable);

    			if (y_AST != null)
    			{
    			System.out.println("WARNING:  ignoring " +
    			y_AST.getText() +
    			" " +
    			d_AST.getText() +
    			" Data Server option to ADD TABLE statement");
    			}

    			table_props();
    			astFactory.addASTChild(currentAST, returnAST);
    			{
    			_loop26:
    			do {
    				if ((LA(1)==KW_ADD) && (LA(2)==KW_FIELD)) {
    					fsig=field(fields, fieldTypes, idx);
    					astFactory.addASTChild(currentAST, returnAST);

    					signature += (signature.length() == 0) ? fsig : "|" + fsig;
    					idx = idx + 1;

    				}
    				else if ((LA(1)==KW_ADD) && (LA(2)==KW_INDEX)) {
    					isig=index(fields, fieldTypes);
    					astFactory.addASTChild(currentAST, returnAST);

    					signature += (signature.length() == 0) ? isig : "%" + isig;

    				}
    				else {
    					break _loop26;
    				}

    			} while (true);
    			}
    			}
    			table_AST = (Aast)currentAST.root;

    			currentTable = null;
    			forceLineColumnNums(tab_AST, table_AST);
    			table_AST.putAnnotation("db_signature", signature);

    			table_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_2);
    		}
    		returnAST = table_AST;
    	}

    /**
     * These UPDATE TABLE and UPDATE INDEX constructs were seen at the bottom of a customer
     * schema, but they don't seem to have any purpose in a converted environment. If these
     * need to be used later, the tree building will have to be improved.
     */
    	public final void update_stuff() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast update_stuff_AST = null;

    		try {      // for error handling
    			Aast tmp6_AST = null;
    			tmp6_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp6_AST);
    			match(KW_UPDATE);
    			{
    			switch ( LA(1)) {
    			case KW_TABLE:
    			{
    				Aast tmp7_AST = null;
    				tmp7_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp7_AST);
    				match(KW_TABLE);
    				Aast tmp8_AST = null;
    				tmp8_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp8_AST);
    				match(STRING);
    				break;
    			}
    			case KW_INDEX:
    			{
    				Aast tmp9_AST = null;
    				tmp9_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp9_AST);
    				match(KW_INDEX);
    				Aast tmp10_AST = null;
    				tmp10_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp10_AST);
    				match(STRING);
    				Aast tmp11_AST = null;
    				tmp11_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp11_AST);
    				match(KW_OF);
    				Aast tmp12_AST = null;
    				tmp12_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp12_AST);
    				match(STRING);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			Aast tmp13_AST = null;
    			tmp13_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp13_AST);
    			match(KW_BUFRPOOL);
    			Aast tmp14_AST = null;
    			tmp14_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp14_AST);
    			match(STRING);
    			update_stuff_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_3);
    		}
    		returnAST = update_stuff_AST;
    	}

    /**
     * Match the trailer section of the file. The data contained in this section
     * is not used for P2J conversion purposes, but provides a handy mechanism
     * to detect that we have successfully reached the end of the database schema
     * definitions section.
     * <p>
     * This matches some <code>DOT</code> tokens, some code-page related keywords
     * and then matches the bytecount numeric token which completes the file.
     * <p>
     * The sub-tree created by this rule will be rooted at an artificial
     * <code>TRAILER</code> node. The first child will be the sub-tree from the
     * code_page rule and the second child will be the <code>NUM_LITERAL</code>
     * which represents the byte or character count for the file.
     */
    	public final void trailer() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast trailer_AST = null;
    		Aast c_AST = null;

    		try {      // for error handling
    			astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(TRAILER));
    			match(DOT);
    			match(KW_PSC);
    			{
    			switch ( LA(1)) {
    			case KW_BUFPOOL:
    			{
    				bufpool();
    				astFactory.addASTChild(currentAST, returnAST);
    				break;
    			}
    			case KW_CP:
    			case KW_CPSTREAM:
    			{
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			code_page();
    			c_AST = (Aast)returnAST;
    			astFactory.addASTChild(currentAST, returnAST);
    			match(DOT);
    			Aast tmp18_AST = null;
    			tmp18_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp18_AST);
    			match(NUM_LITERAL);
    			trailer_AST = (Aast)currentAST.root;

    			forceLineColumnNums(c_AST, trailer_AST);

    			trailer_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_1);
    		}
    		returnAST = trailer_AST;
    	}

    /**
     * Optional <code>BUFPOOL</code> keyword followed by an <code>EQUALS</code> and
     * a boolean literal.  This can appear in the {@link #trailer}.
     */
    	public final void bufpool() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast bufpool_AST = null;

    		try {      // for error handling
    			Aast tmp19_AST = null;
    			tmp19_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp19_AST);
    			match(KW_BUFPOOL);
    			match(EQUALS);
    			{
    			switch ( LA(1)) {
    			case BOOL_TRUE:
    			{
    				Aast tmp21_AST = null;
    				tmp21_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp21_AST);
    				match(BOOL_TRUE);
    				break;
    			}
    			case BOOL_FALSE:
    			{
    				Aast tmp22_AST = null;
    				tmp22_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp22_AST);
    				match(BOOL_FALSE);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			bufpool_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_4);
    		}
    		returnAST = bufpool_AST;
    	}

    /**
     * Code-page related keywords and a code-page name as a <code>SYMBOL</code>.
     * <p>
     * The sub-tree created by this rule will be rooted at the <code>KW_PSC</code>
     * node and all following nodes will be it's direct children.
     */
    	public final void code_page() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast code_page_AST = null;

    		try {      // for error handling
    			{
    			switch ( LA(1)) {
    			case KW_CPSTREAM:
    			{
    				Aast tmp23_AST = null;
    				tmp23_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp23_AST);
    				match(KW_CPSTREAM);
    				break;
    			}
    			case KW_CP:
    			{
    				Aast tmp24_AST = null;
    				tmp24_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp24_AST);
    				match(KW_CP);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			match(EQUALS);
    			any_ridiculous_symbol();
    			astFactory.addASTChild(currentAST, returnAST);
    			code_page_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_5);
    		}
    		returnAST = code_page_AST;
    	}

    /**
     * Match any kind of text as a symbol, even if the text would not normally be allowed to start
     * a symbol (e.g. like a number or some punctuation). The resulting token will be of type
     * SYMBOL.
     */
    	public final void any_ridiculous_symbol() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast any_ridiculous_symbol_AST = null;

    		try {      // for error handling

    			mergeUntilWS();
    			LT(1).setType(SYMBOL);

    			{
    			if ((LA(1)==SYMBOL)) {
    				Aast tmp26_AST = null;
    				tmp26_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp26_AST);
    				match(SYMBOL);
    			}
    			else if ((_tokenSet_6.member(LA(1)))) {
    				Aast tmp27_AST = null;
    				tmp27_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp27_AST);
    				matchNot(Token.EOF_TYPE);
    			}
    			else {
    				throw new NoViableAltException(LT(1), getFilename());
    			}

    			}
    			any_ridiculous_symbol_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_5);
    		}
    		returnAST = any_ridiculous_symbol_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>INITIAL</code> property of a sequence or field.
     * <p>
     * Matches:
     * <ol>
     *    <li> the <code>KW_INIT</code> keyword token
     *    <li> a {@link #literal}
     * </ol>
     * <p>
     * The schema dump file encloses all data values inside double quotes
     * and the lexer doesn't know when to remove the quotes and when to leave
     * them, since the necessary context is only known to the parser.  Only the
     * parser can know this based on the data type of the field or the fact that
     * this is a sequence.  This results in the <code>INITIAL</code> construct
     * having children that are of the <code>STRING</code> type even when they
     * should be some other kind of literal.  <b>To resolve this issue, the
     * <code>relex</code> helper method is used and the offending token is
     * overwritten in the init method. Then the matching continues as it should
     * with no problems and having the correct types.  WARNING: this rewriting does
     * not handle the situation where multiple tokens exist *inside* a single
     * <code>STRING</code> token!</b>
     * <p>
     * <b>WARNING: in normal Progress 4GL source, when extent &gt; 0, this same
     * construct can have a list of comma-separated values. No examples have been
     * encountered yet and the code in this rule won't match such conditions.</b>
     * <p>
     * The sub-tree created by this rule is rooted at a <code>KW_INIT</code> and
     * that node will have a single child which is the literal initial value.
     * <p>
     * If this construct is encountered while parsing the definition for a field
     * of type <code>RAW</code>, the tokens will be discarded and no sub-tree will
     * be created. This is done since it is invalid to initialize a field of that
     * type.
     *
     * @param    ftype
     *           The data type of the field or sequence being processed for the
     *           initial clause.
     * @param    fmt
     *           The format string to be used in manhandling user-defined logical
     *           'constants' or <code>null</code> if no format string exists.
     */
    	public final void initial(
    		int ftype, String fmt
    	) throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast initial_AST = null;
    		Aast l_AST = null;
    		Aast d_AST = null;

    		try {      // for error handling

    			Token   content = LT(2);
    			boolean eat     = false;
    			int     oldtype = -1;

    			// TODO: what does a BLOB or CLOB initializer look like?

    			// it may be time to rewrite our token!
    			if (content.getType() == STRING        &&
    			ftype             != FIELD_CHAR    &&
    			ftype             != FIELD_FIXCHAR)
    			{
    			// OK, we need to re-lex!
    			Token fixed = relex(content.getText());

    			if (fixed != null)
    			{
    			int newType = fixed.getType();

    			// user-defined logical manhandling!
    			if (ftype    == FIELD_LOGICAL &&
    			newType  != BOOL_TRUE     &&
    			newType  != BOOL_FALSE    &&
    			newType  != UNKNOWN_VAL)
    			{
    			// fixups for ridiculous Progress schema feature of allowing
    			// arbitrary user-defined strings (that are an exact match
    			// or an unambiguous abbreviated) match to a format string
    			// of the form "XXX/YYY" --> x, X, xx, XX, xxx, XXX all
    			// resolve to BOOL_TRUE and y, Y, yy, YY, yyy, YYY resolve
    			// to BOOL_FALSE

    			int match = -1;
    			if (fmt != null)
    			{
    			String lower = fmt.toLowerCase();
    			match = lower.indexOf(fixed.getText().toLowerCase());
    			}

    			if (match == 1)   // ignore opening double quote character
    			{
    			fixed.setType(BOOL_TRUE);
    			}
    			else
    			{
    			fixed.setType(BOOL_FALSE);
    			}
    			}

    			// date-specific fixups
    			if (ftype == FIELD_DATE)
    			{
    			if (newType == KW_TODAY)
    			{
    			// use of 'today' as a date literal manhandling!
    			oldtype = KW_TODAY;
    			fixed.setType(DATE_LITERAL);
    			}
    			else if (newType != DATE_LITERAL)
    			{
    			// deal with garbage input;  it is possible to code something like:
    			// INITIAL "this is total crap for a date initial value"
    			// we treat this as unknown value
    			fixed.setText("?");
    			fixed.setType(UNKNOWN_VAL);
    			}
    			}

    			// use of 'now' as a datetime literal manhandling!
    			if ((ftype == FIELD_DATETIME || ftype == FIELD_DATETIME_TZ))
    			{
    			if (newType == KW_NOW)
    			{
    			oldtype = KW_NOW;
    			}
    			else
    			{
    			// restore what relex has broken (by dropping time from timestamp)
    			String txt = content.getText();
    			txt = removeBogusQuotes(txt);
    			oldtype = STRING;
    			fixed.setText(txt);
    			}
    			fixed.setType(DATETIME_TZ_LITERAL);
    			}

    			// blank string for numeric types is interpreted as 0 by Progress
    			if ((ftype == FIELD_INT ||
    			ftype == FIELD_INT64 ||
    			ftype == FIELD_DEC ||
    			ftype == FIELD_RECID) && newType == EOF)
    			{
    			fixed.setText("0");
    			fixed.setType(NUM_LITERAL);
    			}

    			int fixedType = fixed.getType();

    			// only update the type and text if we found a new match,
    			// otherwise defer the fix to later...
    			if (fixedType == UNKNOWN_VAL          || fixedType == BOOL_TRUE        || fixedType == BOOL_FALSE   ||
    			fixedType == NUM_LITERAL          || fixedType == HEX_LITERAL      || fixedType == DEC_LITERAL  ||
    			fixedType == DATE_LITERAL         || fixedType == DATETIME_LITERAL || fixedType == KW_TODAY     ||
    			fixedType == DATETIME_TZ_LITERAL  || fixedType == KW_NOW)
    			{
    			content.setText(fixed.getText());
    			content.setType(fixed.getType());
    			}
    			}
    			else
    			{
    			if (ftype == FIELD_RAW)
    			{
    			// initializers don't make sense for raw fields!
    			eat = true;
    			}
    			else if (ftype == FIELD_INT   ||
    			ftype == FIELD_INT64 ||
    			ftype == FIELD_DEC   ||
    			ftype == FIELD_RECID)
    			{
    			content.setType(NUM_LITERAL);
    			content.setText("0");
    			}
    			else if (ftype == FIELD_LOGICAL)
    			{
    			content.setType(BOOL_FALSE);
    			}
    			}
    			}

    			Aast tmp28_AST = null;
    			tmp28_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp28_AST);
    			match(KW_INIT);
    			{
    			switch ( LA(1)) {
    			case BOOL_TRUE:
    			case BOOL_FALSE:
    			case DEC_LITERAL:
    			case DATE_LITERAL:
    			case DATETIME_TZ_LITERAL:
    			case STRING:
    			case UNKNOWN_VAL:
    			case NUM_LITERAL:
    			{
    				literal();
    				l_AST = (Aast)returnAST;
    				astFactory.addASTChild(currentAST, returnAST);
    				break;
    			}
    			case KW_NOW:
    			case KW_TODAY:
    			{
    				date_initial_keywords();
    				d_AST = (Aast)returnAST;
    				astFactory.addASTChild(currentAST, returnAST);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			initial_AST = (Aast)currentAST.root;

    			// consume the result and null out the subtree if the result makes
    			// no sense (e.g. no initializers in raw fields)
    			if (eat)
    			{
    			initial_AST = null;
    			}
    			else
    			{
    			if (oldtype != -1)
    			{
    			Aast value = (l_AST != null ? l_AST : d_AST);
    			// save off the old type as an annotation
    			value.putAnnotation("oldtype", Long.valueOf(oldtype));
    			}
    			}

    			currentAST.root = initial_AST;
    			currentAST.child = initial_AST!=null &&initial_AST.getFirstChild()!=null ?
    				initial_AST.getFirstChild() : initial_AST;
    			currentAST.advanceChildToEnd();
    			initial_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_7);
    		}
    		returnAST = initial_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>INCREMENT</code> property of a sequence.
     * <p>
     * Matches:
     * <ol>
     * <li>the <code>KW_INCR</code> token
     * <li>the value of the property as a <code>NUM_LITERAL</code>
     * </ol>
     * <p>
     * The sub-tree produced as a result consists of a <code>INCREMENT</code>
     * node representing the property key (the <code>KW_INCR</code> type is
     * replaced) and a single child node with a type of <code>NUM_LITERAL</code>.
     */
    	public final void increment() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast increment_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_INCR);
    			Aast tmp29_AST = null;
    			tmp29_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp29_AST);
    			match(NUM_LITERAL);
    			k_AST.setType(INCREMENT);
    			increment_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_8);
    		}
    		returnAST = increment_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>CYCLE-ON-LIMIT</code> property of a sequence.
     * <p>
     * The sub-tree produced as a result consists of a <code>CYCLE_ON_LIMIT</code>
     * node representing the property key (this replaces the <code>KW_CYCLE</code>
     * token) and a single child node with the value as a literal.
     */
    	public final void cycleOnLimit() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast cycleOnLimit_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_CYCLE);
    			literal();
    			astFactory.addASTChild(currentAST, returnAST);
    			k_AST.setType(CYCLE_ON_LIMIT);
    			cycleOnLimit_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_8);
    		}
    		returnAST = cycleOnLimit_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>MIN-VAL</code> property of a sequence.
     * <p>
     * Matches:
     * <ol>
     *    <li> the <code>KW_MIN_VAL</code> keyword token
     *    <li> a <code>NUM_LITERAL</code>
     * </ol>
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_MIN_VAL</code>
     * node representing the property key and a single child node with a type of
     * <code>NUM_LITERAL</code>.
     */
    	public final void minVal() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast minVal_AST = null;

    		try {      // for error handling
    			Aast tmp30_AST = null;
    			tmp30_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp30_AST);
    			match(KW_MIN_VAL);
    			Aast tmp31_AST = null;
    			tmp31_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp31_AST);
    			match(NUM_LITERAL);
    			minVal_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_8);
    		}
    		returnAST = minVal_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>MAX-VAL</code> property of a sequence.
     * <p>
     * Matches:
     * <ol>
     *    <li> the <code>KW_MAX_VAL</code> keyword token
     *    <li> a <code>NUM_LITERAL</code>
     * </ol>
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_MAX_VAL</code>
     * node representing the property key and a single child node with a type of
     * <code>NUM_LITERAL</code>.
     */
    	public final void maxVal() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast maxVal_AST = null;

    		try {      // for error handling
    			Aast tmp32_AST = null;
    			tmp32_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp32_AST);
    			match(KW_MAX_VAL);
    			Aast tmp33_AST = null;
    			tmp33_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp33_AST);
    			match(NUM_LITERAL);
    			maxVal_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_8);
    		}
    		returnAST = maxVal_AST;
    	}

    /**
     * Sets the MULTITENANT table flag.
     */
    	public final void multitenant() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast multitenant_AST = null;
    		Token  m = null;
    		Aast m_AST = null;
    		Aast l_AST = null;

    		try {      // for error handling
    			m = LT(1);
    			m_AST = (Aast)astFactory.create(m);
    			astFactory.makeASTRoot(currentAST, m_AST);
    			match(KW_MULTI_TN);
    			literal();
    			l_AST = (Aast)returnAST;
    			astFactory.addASTChild(currentAST, returnAST);
    			multitenant_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_9);
    		}
    		returnAST = multitenant_AST;
    	}

    /**
     * Matches all possible table property definitions.
     * <p>
     * The sub-tree created is rooted at an artificial <code>PROPERTIES</code>
     * node.  Each property is parsed in its own rule.  All of the sub-trees
     * for those properties are attached as children of the root node, in the same
     * order they are encountered in the file.  If no properties are found for
     * a table, this rule doesn't create a sub-tree.
     */
    	public final void table_props() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast table_props_AST = null;

    		try {      // for error handling
    			astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(PROPERTIES));
    			{
    			_loop29:
    			do {
    				switch ( LA(1)) {
    				case KW_AREA:
    				case KW_NO_DEFAR:
    				{
    					area();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_MULTI_TN:
    				{
    					multitenant();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LABEL:
    				{
    					label();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LABEL_SA:
    				{
    					label_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_DESCR:
    				{
    					description();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_VALEXP:
    				{
    					valExp();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_VALMSG:
    				{
    					valMsg();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_VALMG_SA:
    				{
    					valMsg_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_FROZEN:
    				{
    					frozen();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_HIDDEN:
    				{
    					hidden();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_DMP_NAME:
    				{
    					dumpName();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CATEGORY:
    				{
    					category();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CAN_CREA:
    				case KW_CAN_DEL:
    				case KW_CAN_DUMP:
    				case KW_CAN_LOAD:
    				case KW_CAN_READ:
    				case KW_CAN_WRT:
    				{
    					permissions();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_TAB_TRG:
    				{
    					table_trigger();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case SYMBOL:
    				{
    					unknownOption();
    					break;
    				}
    				default:
    				{
    					break _loop29;
    				}
    				}
    			} while (true);
    			}
    			table_props_AST = (Aast)currentAST.root;

    			if (table_props_AST.getNumberOfChildren() == 0)
    			{
    			table_props_AST = null;
    			}
    			else
    			{
    			forceLineColumnNums(table_props_AST.getChildAt(0), table_props_AST);
    			}

    			currentAST.root = table_props_AST;
    			currentAST.child = table_props_AST!=null &&table_props_AST.getFirstChild()!=null ?
    				table_props_AST.getFirstChild() : table_props_AST;
    			currentAST.advanceChildToEnd();
    			table_props_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_2);
    		}
    		returnAST = table_props_AST;
    	}

    /**
     * This rule matches a field definition, which consists of the
     * <code>ADD FIELD</code> phrase followed by field property definitions, some
     * of which are optional.
     * <p>
     * An AST is produced as a result, consisting of an artificial
     * <code>FIELD_*</code> node, with its type assigned based on the data type of
     * the field as returned by the <code>as_clause</code> rule (see that rule for
     * the specific types that can be returned).  The text of that root node is the
     * field name as parsed from the text of the first <code>STRING</code> token.
     * The <code>KW_ADD</code>, <code>KW_FIELD</code>, <code>STRING</code>,
     * <code>KW_OF</code> and <code>STRING</code> tokens are all dropped from the
     * tree.  Likewise, the sub-tree for <code>as_clause</code> is dropped, but as
     * noted above, the data type is used as the root node type.  The children of
     * this node will be the sub-trees created by the rule references for the field
     * properties.  In the case of the <code>KW_MAND</code> and
     * <code>KW_CASE_SEN</code> tokens, the node is directly added as a child of
     * the root (but in the case of <code>KW_MAND</code> it is converted to
     * artificial type <code>MANDATORY</code>).
     * <p>
     * Implementation Note:
     * There is an assertion within this method to ensure that the table name
     * associated with the table field being parsed is the same as the name of
     * the table definition most recently parsed. This ensures that this field
     * definition, which is assumed to be in the context of the most recent table
     * definition, is properly "nested" as expected within that table. This is
     * not a critical assertion at runtime, but was a reality check during
     * development of this grammar, to confirm the assumption that a field
     * definition would always be a child of the most recently parsed table
     * definition.
     *
     * @param    fields
     *           The mapping of the field names to their position in the table definition.
     * @param    fieldTypes
     *           The mapping of the field names to their defined type (the token type).
     * @return   The signature for this field in "datatype" or "datatype[extent]" format.
     *
     * @throws   SemanticException
     *           if this field definition reports a different parent table name
     *           from the table definition most recently parsed.
     */
    	public final String  field(
    		Map<String, Integer> fields, Map<String, Integer> fieldTypes, int idx
    	) throws RecognitionException, TokenStreamException {
    		String sig = null;

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast field_AST = null;
    		Token  f = null;
    		Aast f_AST = null;
    		Token  s = null;
    		Aast s_AST = null;
    		Token  t = null;
    		Aast t_AST = null;
    		Aast ff_AST = null;
    		Token  m = null;
    		Aast m_AST = null;
    		Token  n = null;
    		Aast n_AST = null;
    		Token  na = null;
    		Aast na_AST = null;

    		try {      // for error handling

    			int    ftype;
    			String fmt = null;
    			String ext = null;
    			String hist = null;

    			{
    			match(KW_ADD);
    			f = LT(1);
    			f_AST = (Aast)astFactory.create(f);
    			astFactory.makeASTRoot(currentAST, f_AST);
    			match(KW_FIELD);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			match(STRING);

    			hist = removeBogusQuotes(s_AST.getText());
    			f_AST.setText(hist.toLowerCase());
    			f_AST.putAnnotation("historical", hist);

    			match(KW_OF);
    			t = LT(1);
    			t_AST = (Aast)astFactory.create(t);
    			match(STRING);
    			if (!( removeBogusQuotes(t_AST.getText()).equalsIgnoreCase(currentTable) ))
    			  throw new SemanticException(" removeBogusQuotes(t_AST.getText()).equalsIgnoreCase(currentTable) ");
    			ftype=as_clause();
    			f_AST.setType(ftype);
    			{
    			_loop33:
    			do {
    				switch ( LA(1)) {
    				case KW_DESCR:
    				{
    					description();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_FORMAT:
    				{
    					format();
    					ff_AST = (Aast)returnAST;
    					astFactory.addASTChild(currentAST, returnAST);
    					fmt = ff_AST.getChildAt(0).getChildAt(0).getText();
    					break;
    				}
    				case KW_FMT_SA:
    				{
    					format_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_INIT:
    				{
    					initial(ftype, fmt);
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_INIT_SA:
    				{
    					initial_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LABEL:
    				{
    					label();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LABEL_SA:
    				{
    					label_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_POS:
    				{
    					position();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_SQL_WID:
    				{
    					sqlWidth();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_VALMSG:
    				{
    					valMsg();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_VALMG_SA:
    				{
    					valMsg_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_COL_LAB:
    				{
    					columnLabel();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_COL_L_SA:
    				{
    					columnLabel_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CAN_CREA:
    				case KW_CAN_DEL:
    				case KW_CAN_DUMP:
    				case KW_CAN_LOAD:
    				case KW_CAN_READ:
    				case KW_CAN_WRT:
    				{
    					permissions();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_FLD_TRG:
    				{
    					field_trigger();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_HELP:
    				{
    					help();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_HELP_SA:
    				{
    					help_sa();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_EXTENT:
    				{
    					ext=extent();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LENGTH:
    				{
    					length();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_ORDER:
    				{
    					order();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_MAND:
    				{
    					m = LT(1);
    					m_AST = (Aast)astFactory.create(m);
    					astFactory.addASTChild(currentAST, m_AST);
    					match(KW_MAND);
    					m_AST.setType(MANDATORY);
    					break;
    				}
    				case KW_CASE_SEN:
    				{
    					Aast tmp36_AST = null;
    					tmp36_AST = (Aast)astFactory.create(LT(1));
    					astFactory.addASTChild(currentAST, tmp36_AST);
    					match(KW_CASE_SEN);
    					break;
    				}
    				case KW_NOT_CS:
    				{
    					n = LT(1);
    					n_AST = (Aast)astFactory.create(n);
    					match(KW_NOT_CS);

    					outputWarning(n_AST, "WARNING: ignoring cruft ", "");

    					break;
    				}
    				case KW_NULLALWD:
    				{
    					na = LT(1);
    					na_AST = (Aast)astFactory.create(na);
    					match(KW_NULLALWD);

    					outputWarning(na_AST, "WARNING: ignoring cruft ", "");

    					break;
    				}
    				case KW_MAX_WID:
    				{
    					maxWidth();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LOB_AREA:
    				{
    					lobArea();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LOB_BYTE:
    				{
    					lobBytes();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_LOB_SIZE:
    				{
    					lobSize();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CLOB_CP:
    				{
    					clobCodepage();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CLOB_COL:
    				{
    					clobCollation();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_CLOB_TYP:
    				{
    					clobType();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case SYMBOL:
    				{
    					unknownOption();
    					break;
    				}
    				default:
    					if ((LA(1)==KW_VALEXP) && (LA(2)==STRING)) {
    						valExp();
    						astFactory.addASTChild(currentAST, returnAST);
    					}
    					else if ((LA(1)==KW_DECIMALS) && (LA(2)==NUM_LITERAL)) {
    						decimals();
    						astFactory.addASTChild(currentAST, returnAST);
    					}
    					else if ((LA(1)==KW_VIEW_AS) && (LA(2)==STRING)) {
    						viewAs();
    						astFactory.addASTChild(currentAST, returnAST);
    					}
    					else if ((LA(1)==KW_VALEXP||LA(1)==KW_DECIMALS||LA(1)==KW_VIEW_AS) && (LA(2)==UNKNOWN_VAL)) {
    						cruft();
    					}
    				else {
    					break _loop33;
    				}
    				}
    			} while (true);
    			}
    			}

    			sig = fieldSignature(ftype, ext);
    			fields.put(hist.toLowerCase(), idx);
    			fieldTypes.put(hist.toLowerCase(), ftype);

    			field_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_2);
    		}
    		returnAST = field_AST;
    		return sig;
    	}

    /**
     * Matches an index definition, which consists of the <code>ADD INDEX</code>
     * phrase followed by index property definitions, some of which are optional,
     * followed by some number of child entity {@link #indexField definitions}
     * (field references).  The index name is found in the first <code>STRING</code>
     * token and the table name on which the index is based is found in the second
     * <code>STRING</code> token (after the <code>KW_ON</code>).
     * <p>
     * A sub-tree is produced as a result, consisting of an artificial
     * <code>INDEX</code> token node, with an artificial <code>PROPERTIES</code>
     * child node containing the index properties, and an artificial
     * <code>INDEX_FIELD</code> child node for each field of this index. The text
     * of the <code>INDEX</code> node will be set as the index name read from the
     * first <code>STRING</code> token.  The <code>KW_ADD</code>,
     * <code>KW_INDEX</code>, <code>STRING</code>, <code>KW_ON</code> and
     * <code>STRING</code> tokens are all dropped from the tree.
     * <p>
     * Implementation Note:
     * There is an assertion within this method to ensure that the table name
     * associated with the table index being parsed is the same as the name of
     * the table definition most recently parsed. This ensures that this index
     * definition, which is assumed to be in the context of the most recent table
     * definition, is properly "nested" as expected within that table. This is
     * not a critical assertion at runtime, but was a reality check during
     * development of this grammar, to confirm the assumption that an index
     * definition would always be a child of the most recently parsed table
     * definition.
     *
     * @param    fields
     *           The mapping of the field names to their position in the table definition.
     * @param    fieldTypes
     *           The mapping of the field names to their defined type (the token type).
     *
     * @return   sig
     *           The index signature, which includes the index name, options, field position and type.
     *
     * @throws  SemanticException
     *          if this index definition reports a different parent table name
     *          from the table definition most recently parsed.
     */
    	public final String  index(
    		Map<String, Integer> fields, Map<String, Integer> fieldTypes
    	) throws RecognitionException, TokenStreamException {
    		String sig = null;

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast index_AST = null;
    		Token  i = null;
    		Aast i_AST = null;
    		Token  s = null;
    		Aast s_AST = null;
    		Token  n = null;
    		Aast n_AST = null;
    		Aast fidx_AST = null;

    		try {      // for error handling

    			String idxProps = "";
    			String hist = null;

    			{
    			match(KW_ADD);
    			i = LT(1);
    			i_AST = (Aast)astFactory.create(i);
    			astFactory.makeASTRoot(currentAST, i_AST);
    			match(KW_INDEX);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			match(STRING);

    			hist = removeBogusQuotes(s_AST.getText());
    			i_AST.setType(INDEX);
    			i_AST.setText(hist.toLowerCase());
    			i_AST.putAnnotation("historical", hist);

    			match(KW_ON);
    			n = LT(1);
    			n_AST = (Aast)astFactory.create(n);
    			match(STRING);
    			if (!( removeBogusQuotes(n_AST.getText()).equalsIgnoreCase(currentTable) ))
    			  throw new SemanticException(" removeBogusQuotes(n_AST.getText()).equalsIgnoreCase(currentTable) ");
    			idxProps=index_props();
    			astFactory.addASTChild(currentAST, returnAST);
    			{
    			int _cnt37=0;
    			_loop37:
    			do {
    				if ((LA(1)==KW_IDX_FLD)) {
    					indexField();
    					fidx_AST = (Aast)returnAST;
    					astFactory.addASTChild(currentAST, returnAST);

    					String fname = fidx_AST.getText().toLowerCase();
    					int fidx = fields.get(fname);
    					int ftype = fieldTypes.get(fname);
    					String fsig = fieldSignature(ftype, null); // TODO: extent?

    					sig = (sig == null ? "^" + hist.toLowerCase() : sig) + "^" + fidx + "|" + fsig;

    				}
    				else {
    					if ( _cnt37>=1 ) { break _loop37; } else {throw new NoViableAltException(LT(1), getFilename());}
    				}

    				_cnt37++;
    			} while (true);
    			}
    			}

    			sig = idxProps + sig;

    			index_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_2);
    		}
    		returnAST = index_AST;
    		return sig;
    	}

    /**
     * This rule matches a set of tokens assumed from the caller's context to be the value of the
     * {@code AREA} property of a table or index.
     * <p>
     * The resulting sub-tree will be either:<ul>
     *    <li>a single artificial node of type {@code AREA} with it's text set as the text contents of the
     *          {@code STRING} node. The actual tokens read by the rule will be dropped, in this case
     *    <li>a single node, {@code KW_NO_DEFAR}, in case that {@code NO-DEFAULT-AREA} was specified because
     *          the table is NOT defined as "multi tenant with default".
     * </ul>
     */
    	public final void area() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast area_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			switch ( LA(1)) {
    			case KW_AREA:
    			{
    				k = LT(1);
    				k_AST = (Aast)astFactory.create(k);
    				astFactory.makeASTRoot(currentAST, k_AST);
    				match(KW_AREA);
    				v = LT(1);
    				v_AST = (Aast)astFactory.create(v);
    				match(STRING);

    				k_AST.setType(AREA);
    				k_AST.setText(removeBogusQuotes(v_AST.getText()));

    				area_AST = (Aast)currentAST.root;
    				break;
    			}
    			case KW_NO_DEFAR:
    			{
    				Aast tmp39_AST = null;
    				tmp39_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp39_AST);
    				match(KW_NO_DEFAR);
    				area_AST = (Aast)currentAST.root;
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_10);
    		}
    		returnAST = area_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>LABEL</code> property of a table or field.
     * <p>
     * The resulting sub-tree will be rooted at the <code>KW_LABEL</code> node and
     * the <code>STRING</code> will be its only child node.
     */
    	public final void label() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast label_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			Aast tmp40_AST = null;
    			tmp40_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp40_AST);
    			match(KW_LABEL);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.addASTChild(currentAST, s_AST);
    			match(STRING);
    			label_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = label_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>LABEL-SA</code> property of a table or field.
     * <p>
     * The resulting sub-tree will be rooted at the <code>KW_LABEL</code> node and
     * the <code>STRING</code> will be its only child node.
     */
    	public final void label_sa() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast label_sa_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			Aast tmp41_AST = null;
    			tmp41_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp41_AST);
    			match(KW_LABEL_SA);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.addASTChild(currentAST, s_AST);
    			match(STRING);
    			label_sa_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = label_sa_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>DESCRIPTION</code> property of a table, field,
     * or index.
     * <p>
     * The resulting sub-tree will be rooted at an artificial
     * <code>DESCRIPTION</code> node and the text of that node will be set as
     * the text contents of the <code>STRING</code> node.  Both tokens being
     * matched will be discarded.
     */
    	public final void description() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast description_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_DESCR);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			match(STRING);

    			k_AST.setType(DESCRIPTION);
    			k_AST.setText(removeBogusQuotes(v_AST.getText()));

    			description_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_12);
    		}
    		returnAST = description_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>VALEXP</code> property of a Progress field. This results in
     * a <code>VALEXP</code> AST with a single child of type <code>STRING</code>.
     * The string as read from the DF file is enclosed within double quotes;
     * these are removed. The DF file escapes embedded double quotes in this
     * string by doubling them up. All doubled-up double quotes are replaced
     * with single, double quotes (e.g., ...<code>""some text""</code>... becomes
     * ...<code>"some text"</code>...).
     * <p>
     * <b>The child node will need to be post-processed if it contains a real
     * Progress 4GL expression.</b>
     */
    	public final void valExp() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast valExp_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_VALEXP);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.addASTChild(currentAST, s_AST);
    			match(STRING);

    			String rawText = s_AST.getText();
    			String text = rawText;

    			// store the validation expression in a form suitable for compilation as a string
    			// literal in a Java class; this ultimately will end up as a DMO annotation; here we
    			// have to replace unsafe 4GL characters into a form javac can deal with
    			text = character.progressToJavaString(text);
    			k_AST.putAnnotation("original_text", text);

    			// set the raw text with minimal preprocessing back into the node for post-processing
    			// later
    			text = removeBogusQuotes(rawText);
    			text = text.replaceAll("\"\"", "\"");
    			s_AST.setText(text);
    			k_AST.setType(VALEXP);

    			valExp_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = valExp_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>VALMSG</code> property of a table or field.
     * <p>
     * Matches
     * <ol>
     *    <li> the <code>KW_VALMSG</code> token
     *    <li> a <code>STRING</code>
     * </ol>
     * <p>
     * <p>
     * The resulting AST will be rooted at an artificial <code>VALMSG</code>
     * node, with the <code>STRING</code> as a child of an artificial
     * <code>EXPRESSION</code> node (which makes the <code>STRING</code> the
     * grand-child node to the <code>VALMSG</code>.
     * <p>
     * <b>The child node will need to be post-processed if it contains a real
     * Progress 4GL expression rather than only a string literal. All samples
     * to date are only a simple string so this code will work properly.</b>
     */
    	public final void valMsg() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast valMsg_AST = null;
    		Token  m = null;
    		Aast m_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			m = LT(1);
    			m_AST = (Aast)astFactory.create(m);
    			match(KW_VALMSG);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			match(STRING);
    			valMsg_AST = (Aast)currentAST.root;

    			valMsg_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(VALMSG,"valmsg")).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(EXPRESSION,"expression")).add(v_AST))));
    			forceLineColumnNums(m_AST, valMsg_AST);

    			currentAST.root = valMsg_AST;
    			currentAST.child = valMsg_AST!=null &&valMsg_AST.getFirstChild()!=null ?
    				valMsg_AST.getFirstChild() : valMsg_AST;
    			currentAST.advanceChildToEnd();
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = valMsg_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>VALMG-SA</code> property of a table or field.
     * <p>
     * The resulting sub-tree will be rooted at the <code>KW_LABEL</code> node and
     * the <code>STRING</code> will be its only child node.
     */
    	public final void valMsg_sa() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast valMsg_sa_AST = null;
    		Token  m = null;
    		Aast m_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			m = LT(1);
    			m_AST = (Aast)astFactory.create(m);
    			astFactory.makeASTRoot(currentAST, m_AST);
    			match(KW_VALMG_SA);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			astFactory.addASTChild(currentAST, v_AST);
    			match(STRING);
    			valMsg_sa_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = valMsg_sa_AST;
    	}

    /**
     * Match a token assumed from the caller's context to be the
     * value of the <code>FROZEN</code> property of a table.
     * <p>
     * The resulting AST will be a single node of artificial type
     * <code>FROZEN</code>.
     */
    	public final void frozen() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast frozen_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.addASTChild(currentAST, k_AST);
    			match(KW_FROZEN);
    			k_AST.setType(FROZEN);
    			frozen_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_13);
    		}
    		returnAST = frozen_AST;
    	}

    /**
     * Match a token assumed from the caller's context to be the
     * value of the <code>HIDDEN</code> property of a table.
     * <p>
     * The resulting AST will be a single node of artificial type
     * <code>HIDDEN</code>.
     */
    	public final void hidden() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast hidden_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.addASTChild(currentAST, k_AST);
    			match(KW_HIDDEN);
    			k_AST.setType(HIDDEN);
    			hidden_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_13);
    		}
    		returnAST = hidden_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>DUMP-NAME</code> property of a table.
     * <p>
     * The resulting sub-tree is rooted at an artificial <code>DUMP_NAME</code>
     * node and the text contents of the <code>STRING</code> are set as the text
     * of the root node.  The <code>KW_DMP_NAME</code> and <code>STRING</code>
     * tokens are discarded.
     */
    	public final void dumpName() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast dumpName_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_DMP_NAME);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			match(STRING);

    			k_AST.setType(DUMP_NAME);
    			k_AST.setText(removeBogusQuotes(v_AST.getText()));

    			dumpName_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_13);
    		}
    		returnAST = dumpName_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value of the
     * <code>CATEGORY</code> property of a table.
     * <p>
     * The resulting sub-tree is rooted at an artificial <code>CATEGORY</code> node and the text
     * contents of the <code>STRING</code> are set as the text of the root node.
     * The <code>KW_CATEGORY</code> and <code>STRING</code> tokens are discarded.
     */
    	public final void category() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast category_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_CATEGORY);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			match(STRING);

    			k_AST.setType(CATEGORY);
    			k_AST.setText(removeBogusQuotes(v_AST.getText()));

    			category_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_13);
    		}
    		returnAST = category_AST;
    	}

    /**
     * Match permissions clause as a property of a table or field.
     * <p>
     * The resulting sub-tree will have the permission keyword (e.g.
     * <code>KW_CAN_READ</code> as the root node and the <code>STRING</code> as
     * the child node.
     */
    	public final void permissions() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast permissions_AST = null;

    		try {      // for error handling
    			{
    			switch ( LA(1)) {
    			case KW_CAN_CREA:
    			{
    				Aast tmp42_AST = null;
    				tmp42_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp42_AST);
    				match(KW_CAN_CREA);
    				break;
    			}
    			case KW_CAN_DEL:
    			{
    				Aast tmp43_AST = null;
    				tmp43_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp43_AST);
    				match(KW_CAN_DEL);
    				break;
    			}
    			case KW_CAN_READ:
    			{
    				Aast tmp44_AST = null;
    				tmp44_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp44_AST);
    				match(KW_CAN_READ);
    				break;
    			}
    			case KW_CAN_WRT:
    			{
    				Aast tmp45_AST = null;
    				tmp45_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp45_AST);
    				match(KW_CAN_WRT);
    				break;
    			}
    			case KW_CAN_DUMP:
    			{
    				Aast tmp46_AST = null;
    				tmp46_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp46_AST);
    				match(KW_CAN_DUMP);
    				break;
    			}
    			case KW_CAN_LOAD:
    			{
    				Aast tmp47_AST = null;
    				tmp47_AST = (Aast)astFactory.create(LT(1));
    				astFactory.makeASTRoot(currentAST, tmp47_AST);
    				match(KW_CAN_LOAD);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			Aast tmp48_AST = null;
    			tmp48_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp48_AST);
    			match(STRING);
    			permissions_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = permissions_AST;
    	}

    /**
     * Match a <code>TABLE-TRIGGER</code> clause in the {@link #table_props}.
     * Uses {@link #trigger_parms}.
     * <p>
     * The sub-tree will have the <code>KW_TAB_TRG</code> as the root and the
     * sub-tree created by <code>trigger_parms</code> will be the child.
     */
    	public final void table_trigger() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast table_trigger_AST = null;

    		try {      // for error handling
    			Aast tmp49_AST = null;
    			tmp49_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp49_AST);
    			match(KW_TAB_TRG);
    			trigger_parms();
    			astFactory.addASTChild(currentAST, returnAST);
    			table_trigger_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_13);
    		}
    		returnAST = table_trigger_AST;
    	}

    /**
     * Match any other unrecognized option and warn that it is being dropped. The
     * calling code will actually drop the matched subtree.
     */
    	public final void unknownOption() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast unknownOption_AST = null;
    		Token  s = null;
    		Aast s_AST = null;
    		Aast l_AST = null;

    		try {      // for error handling
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.makeASTRoot(currentAST, s_AST);
    			match(SYMBOL);
    			literal();
    			l_AST = (Aast)returnAST;
    			astFactory.addASTChild(currentAST, returnAST);

    			outputWarning(s_AST,
    			"WARNING: ignoring unknown option ",
    			" with value " + l_AST.getText());

    			unknownOption_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_12);
    		}
    		returnAST = unknownOption_AST;
    	}

    /**
     * Match a set of tokens for the <code>AS</code> clause, which defines the data
     * type of a field.
     * <p>
     * The resulting sub-tree is rooted at the <code>KW_AS</code> node and it will
     * have a single child node which is the data type keyword matched.  More
     * importantly, the data type keyword will set the type for the field as
     * follows:
     * <p>
     * <pre>
     * Type Keyword                Field Data Type
     * --------------------        ---------------------
     * KW_BLOB                     FIELD_BLOB
     * KW_CHAR                     FIELD_CHAR
     * KW_CLOB                     FIELD_CLOB
     * KW_COM_HNDL                 FIELD_COM_HANDLE
     * KW_DATE                     FIELD_DATE
     * KW_DATETIME                 FIELD_DATETIME
     * KW_DATE_TZ                  FIELD_DATETIME_TZ
     * KW_DEC                      FIELD_DEC
     * KW_INT                      FIELD_INT
     * KW_INT64                    FIELD_INT64
     * KW_LOGICAL                  FIELD_LOGICAL
     * KW_RECID                    FIELD_RECID
     * KW_ROWID                    FIELD_ROWID
     * KW_RAW                      FIELD_RAW
     * KW_HANDLE                   FIELD_HANDLE
     * </pre>
     * <p>
     * This parser is used for <code>.df</code> files which are only used with
     * permanent databases.  Since <code>CLASS</code> fields are for temp-tables
     * only, the <code>KW_CLASS</code> cannot be used in a <code>.df</code> file
     * and <code>FIELD_CLASS</code> will not be ever used as a field type in a
     * permanent database.
     * <p>
     * The following can also be matched, but they are only used in metadata
     * schemas, normal Progress databases don't provide these field types.
     * <p>
     * <pre>
     * Type Keyword                Metadata Field Data Type
     * --------------------        ------------------------
     * KW_BIGINT                   FIELD_BIGINT
     * KW_BYTE                     FIELD_BYTE
     * KW_DOUBLE                   FIELD_DOUBLE
     * KW_FIXCHAR                  FIELD_FIXCHAR
     * KW_FLOAT                    FIELD_FLOAT
     * KW_SHORT                    FIELD_SHORT
     * KW_TIMESTMP                 FIELD_TIMESTAMP
     * KW_TIME                     FIELD_TIME
     * </pre>
     *
     * @return   The data type of the field.
     */
    	public final int  as_clause() throws RecognitionException, TokenStreamException {
    		int ftype = -1;

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast as_clause_AST = null;

    		try {      // for error handling
    			Aast tmp50_AST = null;
    			tmp50_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp50_AST);
    			match(KW_AS);
    			{
    			switch ( LA(1)) {
    			case KW_BLOB:
    			{
    				Aast tmp51_AST = null;
    				tmp51_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp51_AST);
    				match(KW_BLOB);
    				ftype = FIELD_BLOB;
    				break;
    			}
    			case KW_CHAR:
    			{
    				Aast tmp52_AST = null;
    				tmp52_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp52_AST);
    				match(KW_CHAR);
    				ftype = FIELD_CHAR;
    				break;
    			}
    			case KW_CLOB:
    			{
    				Aast tmp53_AST = null;
    				tmp53_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp53_AST);
    				match(KW_CLOB);
    				ftype = FIELD_CLOB;
    				break;
    			}
    			case KW_COM_HNDL:
    			{
    				Aast tmp54_AST = null;
    				tmp54_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp54_AST);
    				match(KW_COM_HNDL);
    				ftype = FIELD_COM_HANDLE;
    				break;
    			}
    			case KW_DATE:
    			{
    				Aast tmp55_AST = null;
    				tmp55_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp55_AST);
    				match(KW_DATE);
    				ftype = FIELD_DATE;
    				break;
    			}
    			case KW_DATETIME:
    			{
    				Aast tmp56_AST = null;
    				tmp56_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp56_AST);
    				match(KW_DATETIME);
    				ftype = FIELD_DATETIME;
    				break;
    			}
    			case KW_DATE_TZ:
    			{
    				Aast tmp57_AST = null;
    				tmp57_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp57_AST);
    				match(KW_DATE_TZ);
    				ftype = FIELD_DATETIME_TZ;
    				break;
    			}
    			case KW_DEC:
    			{
    				Aast tmp58_AST = null;
    				tmp58_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp58_AST);
    				match(KW_DEC);
    				ftype = FIELD_DEC;
    				break;
    			}
    			case KW_INT:
    			{
    				Aast tmp59_AST = null;
    				tmp59_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp59_AST);
    				match(KW_INT);
    				ftype = FIELD_INT;
    				break;
    			}
    			case KW_INT64:
    			{
    				Aast tmp60_AST = null;
    				tmp60_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp60_AST);
    				match(KW_INT64);
    				ftype = FIELD_INT64;
    				break;
    			}
    			case KW_LOGICAL:
    			{
    				Aast tmp61_AST = null;
    				tmp61_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp61_AST);
    				match(KW_LOGICAL);
    				ftype = FIELD_LOGICAL;
    				break;
    			}
    			case KW_RECID:
    			{
    				Aast tmp62_AST = null;
    				tmp62_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp62_AST);
    				match(KW_RECID);
    				ftype = FIELD_RECID;
    				break;
    			}
    			case KW_ROWID:
    			{
    				Aast tmp63_AST = null;
    				tmp63_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp63_AST);
    				match(KW_ROWID);
    				ftype = FIELD_ROWID;
    				break;
    			}
    			case KW_RAW:
    			{
    				Aast tmp64_AST = null;
    				tmp64_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp64_AST);
    				match(KW_RAW);
    				ftype = FIELD_RAW;
    				break;
    			}
    			case KW_HANDLE:
    			{
    				Aast tmp65_AST = null;
    				tmp65_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp65_AST);
    				match(KW_HANDLE);
    				ftype = FIELD_HANDLE;
    				break;
    			}
    			case KW_BIGINT:
    			{
    				Aast tmp66_AST = null;
    				tmp66_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp66_AST);
    				match(KW_BIGINT);
    				ftype = FIELD_BIGINT;
    				break;
    			}
    			case KW_BYTE:
    			{
    				Aast tmp67_AST = null;
    				tmp67_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp67_AST);
    				match(KW_BYTE);
    				ftype = FIELD_BYTE;
    				break;
    			}
    			case KW_DOUBLE:
    			{
    				Aast tmp68_AST = null;
    				tmp68_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp68_AST);
    				match(KW_DOUBLE);
    				ftype = FIELD_DOUBLE;
    				break;
    			}
    			case KW_FIXCHAR:
    			{
    				Aast tmp69_AST = null;
    				tmp69_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp69_AST);
    				match(KW_FIXCHAR);
    				ftype = FIELD_FIXCHAR;
    				break;
    			}
    			case KW_FLOAT:
    			{
    				Aast tmp70_AST = null;
    				tmp70_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp70_AST);
    				match(KW_FLOAT);
    				ftype = FIELD_FLOAT;
    				break;
    			}
    			case KW_SHORT:
    			{
    				Aast tmp71_AST = null;
    				tmp71_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp71_AST);
    				match(KW_SHORT);
    				ftype = FIELD_SHORT;
    				break;
    			}
    			case KW_TIMESTMP:
    			{
    				Aast tmp72_AST = null;
    				tmp72_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp72_AST);
    				match(KW_TIMESTMP);
    				ftype = FIELD_TIMESTAMP;
    				break;
    			}
    			case KW_TIME:
    			{
    				Aast tmp73_AST = null;
    				tmp73_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp73_AST);
    				match(KW_TIME);
    				ftype = FIELD_TIME;
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			as_clause_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = as_clause_AST;
    		return ftype;
    	}

    /**
     * Match a set of tokens which is the value of the <code>FORMAT</code> property
     * of a field.
     * <p>
     * The resulting sub-tree is rooted at a <code>KW_FORMAT</code> node with an
     * artificial <code>EXPRESSION</code> child node and the <code>STRING</code>
     * node is a child of the <code>EXPRESSION</code>.
     */
    	public final void format() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast format_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			match(KW_FORMAT);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			match(STRING);
    			format_AST = (Aast)currentAST.root;
    			format_AST = (Aast)astFactory.make( (new ASTArray(2)).add(k_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(EXPRESSION,"expression")).add(v_AST))));
    			currentAST.root = format_AST;
    			currentAST.child = format_AST!=null &&format_AST.getFirstChild()!=null ?
    				format_AST.getFirstChild() : format_AST;
    			currentAST.advanceChildToEnd();
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = format_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>FORMAT_SA</code> property of a table or field.
     * <p>
     * The resulting sub-tree will be rooted at the <code>KW_LABEL</code> node and
     * the <code>STRING</code> will be its only child node.
     */
    	public final void format_sa() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast format_sa_AST = null;
    		Token  m = null;
    		Aast m_AST = null;
    		Token  v = null;
    		Aast v_AST = null;

    		try {      // for error handling
    			m = LT(1);
    			m_AST = (Aast)astFactory.create(m);
    			astFactory.makeASTRoot(currentAST, m_AST);
    			match(KW_FMT_SA);
    			v = LT(1);
    			v_AST = (Aast)astFactory.create(v);
    			astFactory.addASTChild(currentAST, v_AST);
    			match(STRING);
    			format_sa_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = format_sa_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the
     * value of the <code>INITIAL-SA</code> property of a table or field.
     * <p>
     * The resulting sub-tree will be rooted at the <code>KW_LABEL</code> node and
     * the <code>STRING</code> will be its only child node.
     */
    	public final void initial_sa() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast initial_sa_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			Aast tmp74_AST = null;
    			tmp74_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp74_AST);
    			match(KW_INIT_SA);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.addASTChild(currentAST, s_AST);
    			match(STRING);
    			initial_sa_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = initial_sa_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>POSITION</code> property of a Progress field.
     * <p>
     * The resulting sub-tree has an artificial <code>POSITION</code> node with a
     * child node of <code>NUM_LITERAL</code>. The <code>KW_POS</code> is dropped.
     */
    	public final void position() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast position_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_POS);
    			Aast tmp75_AST = null;
    			tmp75_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp75_AST);
    			match(NUM_LITERAL);
    			k_AST.setType(POSITION);
    			position_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = position_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>SQL-WIDTH</code> property of
     * a field.
     * <p>
     * The resulting sub-tree has an artificial <code>SQL_WIDTH</code> node with a
     * child node of <code>NUM_LITERAL</code>. The <code>KW_SQL_WID</code> is
     * dropped.
     */
    	public final void sqlWidth() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast sqlWidth_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_SQL_WID);
    			Aast tmp76_AST = null;
    			tmp76_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp76_AST);
    			match(NUM_LITERAL);
    			k_AST.setType(SQL_WIDTH);
    			sqlWidth_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = sqlWidth_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>COLUMN-LABEL</code> property of a Progress field.
     * <p>
     * The resulting sub-tree is <code>KW_COL_LAB</code> node with a child
     * node of <code>STRING</code>.
     */
    	public final void columnLabel() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast columnLabel_AST = null;

    		try {      // for error handling
    			Aast tmp77_AST = null;
    			tmp77_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp77_AST);
    			match(KW_COL_LAB);
    			Aast tmp78_AST = null;
    			tmp78_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp78_AST);
    			match(STRING);
    			columnLabel_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = columnLabel_AST;
    	}

    /**
     * Match a set of tokens assumed from the caller's context to be the value
     * of the <code>COLUMN-LABEL_SA</code> property of a Progress field.
     * <p>
     * The resulting sub-tree is <code>KW_COL_L_SA</code> node with a child
     * node of <code>STRING</code>.
     */
    	public final void columnLabel_sa() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast columnLabel_sa_AST = null;

    		try {      // for error handling
    			Aast tmp79_AST = null;
    			tmp79_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp79_AST);
    			match(KW_COL_L_SA);
    			Aast tmp80_AST = null;
    			tmp80_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp80_AST);
    			match(STRING);
    			columnLabel_sa_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = columnLabel_sa_AST;
    	}

    /**
     * Match a <code>FIELD-TRIGGER</code> clause in the {@link #field}.
     * Uses {@link #trigger_parms}.
     * <p>
     * The sub-tree will have the <code>KW_FLD_TRG</code> as the root and the
     * sub-tree created by <code>trigger_parms</code> will be the child.
     */
    	public final void field_trigger() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast field_trigger_AST = null;

    		try {      // for error handling
    			Aast tmp81_AST = null;
    			tmp81_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp81_AST);
    			match(KW_FLD_TRG);
    			trigger_parms();
    			astFactory.addASTChild(currentAST, returnAST);
    			field_trigger_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = field_trigger_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>HELP</code> property of a
     * field.
     * <p>
     * The resulting sub-tree is the <code>KW_HELP</code> with a child of
     * <code>STRING</code>.
     */
    	public final void help() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast help_AST = null;

    		try {      // for error handling
    			Aast tmp82_AST = null;
    			tmp82_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp82_AST);
    			match(KW_HELP);
    			Aast tmp83_AST = null;
    			tmp83_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp83_AST);
    			match(STRING);
    			help_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = help_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>HELP-SA</code> property of a
     * field.
     * <p>
     * The resulting sub-tree is the <code>KW_HELP_SA</code> with a child of
     * <code>STRING</code>.
     */
    	public final void help_sa() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast help_sa_AST = null;

    		try {      // for error handling
    			Aast tmp84_AST = null;
    			tmp84_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp84_AST);
    			match(KW_HELP_SA);
    			Aast tmp85_AST = null;
    			tmp85_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp85_AST);
    			match(STRING);
    			help_sa_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = help_sa_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>EXTENT</code> property of a
     * field.
     * <p>
     * The resulting sub-tree is the <code>KW_EXTENT</code> with a child of
     * <code>NUM_LITERAL</code>.
     *
     * @return   The size of the extent.
     */
    	public final String  extent() throws RecognitionException, TokenStreamException {
    		String num = null;

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast extent_AST = null;
    		Token  n = null;
    		Aast n_AST = null;

    		try {      // for error handling
    			Aast tmp86_AST = null;
    			tmp86_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp86_AST);
    			match(KW_EXTENT);
    			n = LT(1);
    			n_AST = (Aast)astFactory.create(n);
    			astFactory.addASTChild(currentAST, n_AST);
    			match(NUM_LITERAL);
    			num = n_AST.getText();
    			extent_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = extent_AST;
    		return num;
    	}

    /**
     * Match a set of tokens as the value of the <code>DECIMALS</code> property of
     * a field.
     * <p>
     * The resulting sub-tree is the <code>KW_DECIMALS</code> with a child of
     * <code>NUM_LITERAL</code>.
     */
    	public final void decimals() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast decimals_AST = null;

    		try {      // for error handling
    			Aast tmp87_AST = null;
    			tmp87_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp87_AST);
    			match(KW_DECIMALS);
    			Aast tmp88_AST = null;
    			tmp88_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp88_AST);
    			match(NUM_LITERAL);
    			decimals_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = decimals_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>LENGTH</code> property of a
     * field.
     * <p>
     * The resulting sub-tree is the <code>KW_LENGTH</code> with a child of
     * <code>NUM_LITERAL</code>.
     */
    	public final void length() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast length_AST = null;

    		try {      // for error handling
    			Aast tmp89_AST = null;
    			tmp89_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp89_AST);
    			match(KW_LENGTH);
    			Aast tmp90_AST = null;
    			tmp90_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp90_AST);
    			match(NUM_LITERAL);
    			length_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = length_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>VIEW-AS</code> property of
     * a field. Strangely enough, the <code>KW_VIEW_AS</code> keyword is repeated
     * inside the <code>STRING</code> text.  That is just a Progress 4GL quirk.
     * <p>
     * The resulting sub-tree is the <code>KW_VIEW_AS</code> with a child of
     * <code>STRING</code>.
     * <p>
     * <b>The string literal child will need post-processing to convert it into
     * the full view-as phrase.</b>
     */
    	public final void viewAs() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast viewAs_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			Aast tmp91_AST = null;
    			tmp91_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp91_AST);
    			match(KW_VIEW_AS);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			astFactory.addASTChild(currentAST, s_AST);
    			match(STRING);

    			// DO NOT use remoteBogusQuotes() here, parseProgressCharLiteral() is required to allow
    			// more complex uses of escaped single and double quotes inside the string; the bottom
    			// line is that we need the unescaped runtime version for downstream re-parsing
    			s_AST.setText(character.parseProgressCharLiteral(s_AST.getText(), !unixEsc));

    			viewAs_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = viewAs_AST;
    	}

    /**
     * Match a set of tokens as the value of the <code>ORDER</code> property of a
     * field.
     * <p>
     * The resulting sub-tree is an artificial <code>ORDER</code> with a child of
     * <code>NUM_LITERAL</code>. The <code>KW_ORDER</code> is dropped.
     */
    	public final void order() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast order_AST = null;
    		Token  k = null;
    		Aast k_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_ORDER);
    			Aast tmp92_AST = null;
    			tmp92_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp92_AST);
    			match(NUM_LITERAL);
    			k_AST.setType(ORDER);
    			order_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = order_AST;
    	}

    /**
     * Match <code>MAX-WIDTH</code> keyword and a following
     * <code>NUM_LITERAL</code> for a field.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_MAX_WID</code>
     * node with a single child node with a type of <code>NUM_LITERAL</code>.
     */
    	public final void maxWidth() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast maxWidth_AST = null;

    		try {      // for error handling
    			Aast tmp93_AST = null;
    			tmp93_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp93_AST);
    			match(KW_MAX_WID);
    			Aast tmp94_AST = null;
    			tmp94_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp94_AST);
    			match(NUM_LITERAL);
    			maxWidth_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = maxWidth_AST;
    	}

    /**
     * Match <code>LOB-AREA</code> keyword and a following <code>STRING</code>
     * for a field.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_LOB_AREA</code>
     * node with a single child node with a type of <code>STRING</code>.
     */
    	public final void lobArea() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast lobArea_AST = null;

    		try {      // for error handling
    			Aast tmp95_AST = null;
    			tmp95_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp95_AST);
    			match(KW_LOB_AREA);
    			Aast tmp96_AST = null;
    			tmp96_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp96_AST);
    			match(STRING);
    			lobArea_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = lobArea_AST;
    	}

    /**
     * Match <code>LOB-BYTES</code> keyword and a following
     * <code>NUM_LITERAL</code> for a field.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_LOB_BYTE</code>
     * node with a single child node with a type of <code>NUM_LITERAL</code>.
     */
    	public final void lobBytes() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast lobBytes_AST = null;

    		try {      // for error handling
    			Aast tmp97_AST = null;
    			tmp97_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp97_AST);
    			match(KW_LOB_BYTE);
    			Aast tmp98_AST = null;
    			tmp98_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp98_AST);
    			match(NUM_LITERAL);
    			lobBytes_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = lobBytes_AST;
    	}

    /**
     * Match <code>LOB-SIZE</code> keyword and a following size specification
     * for a field.  The size specification is a integral literal with an optional
     * single letter at the end to specify the units (e.g. 100M).  This will
     * appear as a <code>SYMBOL</code> in the resulting tree, although it
     * doesn't naturally lex that way.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_LOB_SIZE</code>
     * node with a single child node with a type of <code>SYMBOL</code>.  The
     * matched <code>NUM_LITERAL</code> is dropped but the text of that node is
     * prefixed to the text of the <code>SYMBOL</code> node.
     */
    	public final void lobSize() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast lobSize_AST = null;
    		Token  n = null;
    		Aast n_AST = null;
    		Token  s = null;
    		Aast s_AST = null;

    		try {      // for error handling
    			Aast tmp99_AST = null;
    			tmp99_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp99_AST);
    			match(KW_LOB_SIZE);
    			n = LT(1);
    			n_AST = (Aast)astFactory.create(n);
    			astFactory.addASTChild(currentAST, n_AST);
    			match(NUM_LITERAL);
    			{
    			if (((LA(1)==SYMBOL) && (_tokenSet_14.member(LA(2))))&&( !prefacedByWhitespace(LT(1)) )) {
    				s = LT(1);
    				s_AST = (Aast)astFactory.create(s);
    				match(SYMBOL);
    			}
    			else if ((_tokenSet_14.member(LA(1))) && (_tokenSet_15.member(LA(2)))) {
    			}
    			else {
    				throw new NoViableAltException(LT(1), getFilename());
    			}

    			}

    			// put the single size spec back together, if needed
    			if (s_AST != null)
    			{
    			StringBuilder sb = new StringBuilder();
    			sb.append(n_AST.getText()).append(s_AST.getText());
    			n_AST.setText(sb.toString());
    			}

    			n_AST.setType(SYMBOL);

    			lobSize_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = lobSize_AST;
    	}

    /**
     * Match <code>CLOB-CODEPAGE</code> keyword and a following <code>STRING</code>
     * for a field.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_CLOB_CP</code>
     * node with a single child node with a type of <code>STRING</code>.
     */
    	public final void clobCodepage() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast clobCodepage_AST = null;

    		try {      // for error handling
    			Aast tmp100_AST = null;
    			tmp100_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp100_AST);
    			match(KW_CLOB_CP);
    			Aast tmp101_AST = null;
    			tmp101_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp101_AST);
    			match(STRING);
    			clobCodepage_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = clobCodepage_AST;
    	}

    /**
     * Match <code>CLOB-COLLATION</code> keyword and a following <code>STRING</code>
     * for a field.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_CLOB_COL</code>
     * node with a single child node with a type of <code>STRING</code>.
     */
    	public final void clobCollation() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast clobCollation_AST = null;

    		try {      // for error handling
    			Aast tmp102_AST = null;
    			tmp102_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp102_AST);
    			match(KW_CLOB_COL);
    			Aast tmp103_AST = null;
    			tmp103_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp103_AST);
    			match(STRING);
    			clobCollation_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = clobCollation_AST;
    	}

    /**
     * Match <code>CLOB-TYPE</code> keyword and a following <code>NUM_LITERAL</code>
     * for a field.
     * <p>
     * The sub-tree produced as a result consists of a <code>KW_CLOB_TYP</code>
     * node with a single child node with a type of <code>NUM_LITERAL</code>.
     */
    	public final void clobType() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast clobType_AST = null;

    		try {      // for error handling
    			Aast tmp104_AST = null;
    			tmp104_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp104_AST);
    			match(KW_CLOB_TYP);
    			Aast tmp105_AST = null;
    			tmp105_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp105_AST);
    			match(NUM_LITERAL);
    			clobType_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = clobType_AST;
    	}

    /**
     * Match options that make no sense.  This may be related to newer features of
     * v10 which may be forcing all possible options to be output, even those that
     * make no sense for the given type and/or are undefined. The calling code will
     * actually drop the matched subtree.
     */
    	public final void cruft() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast cruft_AST = null;
    		Token  d = null;
    		Aast d_AST = null;
    		Token  v1 = null;
    		Aast v1_AST = null;
    		Token  v2 = null;
    		Aast v2_AST = null;

    		try {      // for error handling
    			{
    			switch ( LA(1)) {
    			case KW_DECIMALS:
    			{
    				d = LT(1);
    				d_AST = (Aast)astFactory.create(d);
    				astFactory.addASTChild(currentAST, d_AST);
    				match(KW_DECIMALS);
    				Aast tmp106_AST = null;
    				tmp106_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp106_AST);
    				match(UNKNOWN_VAL);
    				break;
    			}
    			case KW_VALEXP:
    			{
    				v1 = LT(1);
    				v1_AST = (Aast)astFactory.create(v1);
    				astFactory.addASTChild(currentAST, v1_AST);
    				match(KW_VALEXP);
    				Aast tmp107_AST = null;
    				tmp107_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp107_AST);
    				match(UNKNOWN_VAL);
    				break;
    			}
    			case KW_VIEW_AS:
    			{
    				v2 = LT(1);
    				v2_AST = (Aast)astFactory.create(v2);
    				astFactory.addASTChild(currentAST, v2_AST);
    				match(KW_VIEW_AS);
    				Aast tmp108_AST = null;
    				tmp108_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp108_AST);
    				match(UNKNOWN_VAL);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}

    			Aast n = (d_AST != null) ? d_AST : ((v1_AST != null) ? v1_AST : v2_AST);
    			outputWarning(n, "WARNING: ignoring cruft ", " with value ?");

    			cruft_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_14);
    		}
    		returnAST = cruft_AST;
    	}

    /**
     * Index properties, aggregated as children of an artificial
     * <code>PROPERTIES</code> node, which is itself a direct child of the
     * <code>INDEX</code> node. Each matched keyword is a direct child
     * as are the sub-trees created in the referenced rules.
     *
     * @return   The index options, each encoded with a single character.
     */
    	public final String  index_props() throws RecognitionException, TokenStreamException {
    		String idxProps = "";

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast index_props_AST = null;

    		try {      // for error handling

    			astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(PROPERTIES));
    			boolean isWord = false;
    			boolean isUnique = false;
    			boolean isPrimary = false;
    			boolean isInactive = false;

    			{
    			_loop40:
    			do {
    				switch ( LA(1)) {
    				case KW_AREA:
    				case KW_NO_DEFAR:
    				{
    					area();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_DESCR:
    				{
    					description();
    					astFactory.addASTChild(currentAST, returnAST);
    					break;
    				}
    				case KW_WORD_IDX:
    				{
    					Aast tmp109_AST = null;
    					tmp109_AST = (Aast)astFactory.create(LT(1));
    					astFactory.addASTChild(currentAST, tmp109_AST);
    					match(KW_WORD_IDX);
    					isWord = true;
    					break;
    				}
    				case KW_UNIQUE:
    				{
    					Aast tmp110_AST = null;
    					tmp110_AST = (Aast)astFactory.create(LT(1));
    					astFactory.addASTChild(currentAST, tmp110_AST);
    					match(KW_UNIQUE);
    					isUnique = true;
    					break;
    				}
    				case KW_PRIMARY:
    				{
    					Aast tmp111_AST = null;
    					tmp111_AST = (Aast)astFactory.create(LT(1));
    					astFactory.addASTChild(currentAST, tmp111_AST);
    					match(KW_PRIMARY);
    					isPrimary = true;
    					break;
    				}
    				case KW_INACTIVE:
    				{
    					Aast tmp112_AST = null;
    					tmp112_AST = (Aast)astFactory.create(LT(1));
    					astFactory.addASTChild(currentAST, tmp112_AST);
    					match(KW_INACTIVE);
    					isInactive = true;
    					break;
    				}
    				case SYMBOL:
    				{
    					unknownOption();
    					break;
    				}
    				default:
    				{
    					break _loop40;
    				}
    				}
    			} while (true);
    			}
    			index_props_AST = (Aast)currentAST.root;

    			// the properties can be in any order, standardize the order now
    			if (isWord)
    			{
    			idxProps += "W";
    			}
    			if (isUnique)
    			{
    			idxProps += "U";
    			}
    			if (isPrimary)
    			{
    			idxProps += "P";
    			}
    			if (isInactive)
    			{
    			idxProps += "I";
    			}

    			if (index_props_AST.getNumberOfChildren() == 0)
    			{
    			index_props_AST = null;
    			}
    			else
    			{
    			forceLineColumnNums(index_props_AST.getChildAt(0), index_props_AST);
    			}

    			currentAST.root = index_props_AST;
    			currentAST.child = index_props_AST!=null &&index_props_AST.getFirstChild()!=null ?
    				index_props_AST.getFirstChild() : index_props_AST;
    			currentAST.advanceChildToEnd();
    			index_props_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_16);
    		}
    		returnAST = index_props_AST;
    		return idxProps;
    	}

    /**
     * Matches an index field definition, which consists of the
     * <code>INDEX-FIELD</code> keyword followed by index field property
     * definitions, some of which are optional.
     * <p>
     * An AST is produced as a result, consisting of an imaginary
     * <code>INDEX_FIELD</code> token node, with child nodes for each property
     * encountered.
     */
    	public final void indexField() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast indexField_AST = null;
    		Token  k = null;
    		Aast k_AST = null;
    		Token  s = null;
    		Aast s_AST = null;
    		Token  a = null;
    		Aast a_AST = null;

    		try {      // for error handling
    			k = LT(1);
    			k_AST = (Aast)astFactory.create(k);
    			astFactory.makeASTRoot(currentAST, k_AST);
    			match(KW_IDX_FLD);
    			k_AST.setType(INDEX_FIELD);
    			s = LT(1);
    			s_AST = (Aast)astFactory.create(s);
    			match(STRING);
    			k_AST.setText(removeBogusQuotes(s_AST.getText()));
    			{
    			switch ( LA(1)) {
    			case KW_ASC:
    			{
    				a = LT(1);
    				a_AST = (Aast)astFactory.create(a);
    				astFactory.addASTChild(currentAST, a_AST);
    				match(KW_ASC);
    				a_AST.setType(KW_ASCEND);
    				break;
    			}
    			case KW_DESCEND:
    			{
    				Aast tmp113_AST = null;
    				tmp113_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp113_AST);
    				match(KW_DESCEND);
    				break;
    			}
    			case DOT:
    			case KW_ABBV:
    			case KW_IDX_FLD:
    			case KW_ADD:
    			case KW_UPDATE:
    			{
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			{
    			switch ( LA(1)) {
    			case KW_ABBV:
    			{
    				Aast tmp114_AST = null;
    				tmp114_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp114_AST);
    				match(KW_ABBV);
    				break;
    			}
    			case DOT:
    			case KW_IDX_FLD:
    			case KW_ADD:
    			case KW_UPDATE:
    			{
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			indexField_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_17);
    		}
    		returnAST = indexField_AST;
    	}

    /**
     * Matches a single instance of any and all legal Progress 4GL literals
     * (hard-coded instances of data types, otherwise called constants).  Such
     * constants are properly tokenized by the lexer and this rule simply allows
     * any of the following tokens to be matched:
     * <pre>
     *    NUM_LITERAL
     *    DEC_LITERAL
     *    STRING
     *    BOOL_TRUE
     *    BOOL_FALSE
     *    DATE_LITERAL
     *    DATETIME_TZ_LITERAL
     *    UNKNOWN_VAL
     * </pre>
     * <p>
     * Note that the documentation states that there is no such thing as a date
     * constant in Progress 4GL, however experience shows that this is not true.
     * <p>
     * There are no literal representations for RECID, ROWID or HANDLE data
     * types since these are internal data structures of the Progress language.
     * One can only obtain an instance of such a value from Progress itself so
     * there is no way to hard-code such a reference as a constant.
     * <p>
     * There is no literal representation for RAW data type.
     * <p>
     * <b>WARNING: this rule is simply copied from the grammar for the
     * <code>ProgressParser</code>!</b>
     * <p>
     * The sub-tree created is a single node of the type and text as created by the
     * lexer.
     */
    	public final void literal() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast literal_AST = null;

    		try {      // for error handling
    			{
    			switch ( LA(1)) {
    			case NUM_LITERAL:
    			{
    				Aast tmp115_AST = null;
    				tmp115_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp115_AST);
    				match(NUM_LITERAL);
    				break;
    			}
    			case DEC_LITERAL:
    			{
    				Aast tmp116_AST = null;
    				tmp116_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp116_AST);
    				match(DEC_LITERAL);
    				break;
    			}
    			case STRING:
    			{
    				Aast tmp117_AST = null;
    				tmp117_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp117_AST);
    				match(STRING);
    				break;
    			}
    			case BOOL_TRUE:
    			{
    				Aast tmp118_AST = null;
    				tmp118_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp118_AST);
    				match(BOOL_TRUE);
    				break;
    			}
    			case BOOL_FALSE:
    			{
    				Aast tmp119_AST = null;
    				tmp119_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp119_AST);
    				match(BOOL_FALSE);
    				break;
    			}
    			case DATE_LITERAL:
    			{
    				Aast tmp120_AST = null;
    				tmp120_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp120_AST);
    				match(DATE_LITERAL);
    				break;
    			}
    			case DATETIME_TZ_LITERAL:
    			{
    				Aast tmp121_AST = null;
    				tmp121_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp121_AST);
    				match(DATETIME_TZ_LITERAL);
    				break;
    			}
    			case UNKNOWN_VAL:
    			{
    				Aast tmp122_AST = null;
    				tmp122_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp122_AST);
    				match(UNKNOWN_VAL);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			literal_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_18);
    		}
    		returnAST = literal_AST;
    	}

    /**
     * Matches any instance of Progress 4GL keywords that could be the value of INITIAL for date or datetime.
    */
    	public final void date_initial_keywords() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast date_initial_keywords_AST = null;

    		try {      // for error handling
    			{
    			switch ( LA(1)) {
    			case KW_NOW:
    			{
    				Aast tmp123_AST = null;
    				tmp123_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp123_AST);
    				match(KW_NOW);
    				date_initial_keywords_AST = (Aast)currentAST.root;
    				date_initial_keywords_AST.setType(DATETIME_TZ_LITERAL);
    				break;
    			}
    			case KW_TODAY:
    			{
    				Aast tmp124_AST = null;
    				tmp124_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp124_AST);
    				match(KW_TODAY);
    				date_initial_keywords_AST = (Aast)currentAST.root;
    				date_initial_keywords_AST.setType(DATE_LITERAL);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			date_initial_keywords_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_7);
    		}
    		returnAST = date_initial_keywords_AST;
    	}

    /**
     * Match parameters for a table or field trigger in {@link #table_trigger} and
     * {@link #field_trigger}, respectively.  Uses {@link #proc_clause} and {@link
     * #crc_clause}.
     * <p>
     * Each of the matched tokens will be attached (in order of occurrence) to the
     * tree of the calling rule.
     */
    	public final void trigger_parms() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast trigger_parms_AST = null;

    		try {      // for error handling
    			Aast tmp125_AST = null;
    			tmp125_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp125_AST);
    			match(STRING);
    			{
    			switch ( LA(1)) {
    			case KW_OVERRIDE:
    			{
    				Aast tmp126_AST = null;
    				tmp126_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp126_AST);
    				match(KW_OVERRIDE);
    				break;
    			}
    			case KW_NO_OVRRD:
    			{
    				Aast tmp127_AST = null;
    				tmp127_AST = (Aast)astFactory.create(LT(1));
    				astFactory.addASTChild(currentAST, tmp127_AST);
    				match(KW_NO_OVRRD);
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(LT(1), getFilename());
    			}
    			}
    			}
    			proc_clause();
    			astFactory.addASTChild(currentAST, returnAST);
    			crc_clause();
    			astFactory.addASTChild(currentAST, returnAST);
    			trigger_parms_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = trigger_parms_AST;
    	}

    /**
     * Matches the <code>PROCEDURE</code> keyword followed by a string literal.
     * Used by {@link #table_trigger} and separated to get the tree structure
     * correct.
     * <p>
     * The sub-tree will have the <code>KW_PROC</code> as the root and the
     * <code>STRING</code> will be the child.
     */
    	public final void proc_clause() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast proc_clause_AST = null;

    		try {      // for error handling
    			Aast tmp128_AST = null;
    			tmp128_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp128_AST);
    			match(KW_PROC);
    			Aast tmp129_AST = null;
    			tmp129_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp129_AST);
    			match(STRING);
    			proc_clause_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_19);
    		}
    		returnAST = proc_clause_AST;
    	}

    /**
     * Matches the <code>CRC</code> keyword followed by a string literal.
     * Used by {@link #table_trigger} and separated to get the tree structure
     * correct.
     * <p>
     * The sub-tree will have the <code>KW_CRC</code> as the root and the
     * <code>STRING</code> will be the child.
     */
    	public final void crc_clause() throws RecognitionException, TokenStreamException {

    		returnAST = null;
    		ASTPair currentAST = new ASTPair();
    		Aast crc_clause_AST = null;

    		try {      // for error handling
    			Aast tmp130_AST = null;
    			tmp130_AST = (Aast)astFactory.create(LT(1));
    			astFactory.makeASTRoot(currentAST, tmp130_AST);
    			match(KW_CRC);
    			Aast tmp131_AST = null;
    			tmp131_AST = (Aast)astFactory.create(LT(1));
    			astFactory.addASTChild(currentAST, tmp131_AST);
    			match(STRING);
    			crc_clause_AST = (Aast)currentAST.root;
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			recover(ex,_tokenSet_11);
    		}
    		returnAST = crc_clause_AST;
    	}

    	public static final String[] _tokenNames = {
    		"<0>",
    		"EOF",
    		"<2>",
    		"NULL_TREE_LOOKAHEAD",
    		"DOT",
    		"FILEROOT",
    		"DB_SYMBOL",
    		"ANY_LOCK",
    		"FILENAME",
    		"BACKSLASH",
    		"LIBRARY_REF",
    		"BEGIN_RECORDTYPES",
    		"TABLE",
    		"BUFFER",
    		"TEMP_TABLE",
    		"WORK_TABLE",
    		"END_RECORDTYPES",
    		"BEGIN_BUFFERTYPES",
    		"NO_REFERENCE",
    		"WEAK_REFERENCE",
    		"STRONG_REFERENCE",
    		"FREE_REFERENCE",
    		"END_BUFFERTYPES",
    		"EXPANDED_SCOPE",
    		"BUFFER_SCOPE",
    		"BEGIN_SCHEMA",
    		"ABBREVIATED",
    		"AREA",
    		"CATEGORY",
    		"CYCLE_ON_LIMIT",
    		"DESCRIPTION",
    		"DUMP_NAME",
    		"FROZEN",
    		"HIDDEN",
    		"INCREMENT",
    		"MANDATORY",
    		"ORDER",
    		"POSITION",
    		"SQL_WIDTH",
    		"TRAILER",
    		"VALEXP",
    		"VALMSG",
    		"VALMG_SA",
    		"BEGIN_SCHEMAKW",
    		"KW_ABBV",
    		"KW_AREA",
    		"KW_BIGINT",
    		"KW_BUFRPOOL",
    		"KW_BUFPOOL",
    		"KW_CATEGORY",
    		"KW_CLOB_CP",
    		"KW_CLOB_COL",
    		"KW_CLOB_TYP",
    		"KW_COL_L_SA",
    		"KW_CRC",
    		"KW_CYCLE",
    		"KW_DMP_NAME",
    		"KW_FLD_TRG",
    		"KW_FIXCHAR",
    		"KW_FMT_SA",
    		"KW_FROZEN",
    		"KW_HELP_SA",
    		"KW_IDX_FLD",
    		"KW_INACTIVE",
    		"KW_INCR",
    		"KW_INIT_SA",
    		"KW_LABEL_SA",
    		"KW_LOB_AREA",
    		"KW_LOB_BYTE",
    		"KW_LOB_SIZE",
    		"KW_MULTI_TN",
    		"KW_NO_DEFAR",
    		"KW_NO_OVRRD",
    		"KW_NOT_CS",
    		"KW_NULLALWD",
    		"KW_PSC",
    		"KW_SEQUENCE",
    		"KW_SQL_WID",
    		"KW_TAB_TRG",
    		"KW_TIMESTMP",
    		"KW_VALEXP",
    		"KW_VALMSG",
    		"KW_VALMG_SA",
    		"END_SCHEMAKW",
    		"BEGIN_METATYPES",
    		"FIELD_BIGINT",
    		"FIELD_BYTE",
    		"FIELD_DOUBLE",
    		"FIELD_FIXCHAR",
    		"FIELD_FLOAT",
    		"FIELD_SHORT",
    		"FIELD_TIMESTAMP",
    		"FIELD_TIME",
    		"END_METATYPES",
    		"END_SCHEMA",
    		"DATABASE",
    		"INDEX",
    		"INDEX_FIELD",
    		"BEGIN_INDEX_MATCH_TYPES",
    		"NO_MATCH",
    		"SELF_REFERENCE",
    		"EQUALITY_MATCH",
    		"BEGINS_MATCH",
    		"RANGE_MATCH",
    		"WORD_MATCH",
    		"SORT_MATCH",
    		"END_INDEX_MATCH_TYPES",
    		"SEQUENCE",
    		"PROPERTIES",
    		"MANY_TO_ONE",
    		"ONE_TO_MANY",
    		"ONE_TO_ONE",
    		"KEY_FIELD",
    		"RAW_STRING",
    		"QUERY",
    		"QUERY_SUBST",
    		"CLIENT_WHERE",
    		"CLIENT_WHERE_SUBST",
    		"EMBEDDED_SQL",
    		"COLUMN_LIST",
    		"BLOCK",
    		"PROCEDURE",
    		"CLASS_DEF",
    		"INTERFACE_DEF",
    		"ENUM_DEF",
    		"METHOD_DEF",
    		"CONSTRUCTOR",
    		"DESTRUCTOR",
    		"CLASS_NAME",
    		"ANNOTATION",
    		"OBJECT_INVOCATION",
    		"METHOD_INVOCATION",
    		"PROPERTY_INVOCATION",
    		"EVENT_SIGNATURE",
    		"DOTNET_DELEGATE",
    		"INT_PROC",
    		"WEB_PROC",
    		"FUNCTION",
    		"INNER_BLOCK",
    		"TRIGGER_BLOCK",
    		"EDITING_BLOCK",
    		"FRAME_SCOPE",
    		"FRAME_ALLOC",
    		"COPY_TO_SB",
    		"COPY_FROM_SB",
    		"CUSTOMER_SPECIFIC",
    		"VALIDATION",
    		"TRANSACTION",
    		"SUB_TRANSACTION",
    		"NO_TRANSACTION",
    		"STATEMENT",
    		"BROKEN_PREPROC_ARG",
    		"LABEL_DEF",
    		"LABEL",
    		"EXPRESSION",
    		"EVENT",
    		"DB_EVENT",
    		"CLASS_EVENT",
    		"EVENT_LIST",
    		"KEY_FUNCTION",
    		"WIDGET_LIST",
    		"WIDGET_POOL",
    		"ASSIGNMENT",
    		"ASSIGN",
    		"ARGUMENTS",
    		"PARAMETER",
    		"HANDLE_TO",
    		"COMMAND_TOKENS",
    		"COMMAND_TEXT",
    		"CONNECT_OPTIONS",
    		"CONNECT_TEXT",
    		"IO_OPTIONS",
    		"PUT_FIELD",
    		"IMPORT_FIELD",
    		"EXPORT_FIELD",
    		"AGGREGATE",
    		"FRAME_PHRASE",
    		"FORMAT_PHRASE",
    		"TRIGGER_PHRASE",
    		"RECORD_PHRASE",
    		"COLOR_PHRASE",
    		"INLINE_VAR_DEF_ARRAY",
    		"INLINE_VAR_DEF",
    		"CONTENT_ARRAY",
    		"FRAME_ELEMENT",
    		"WHEN_LIST",
    		"EMBEDDED_ASSIGNMENT",
    		"FORM_ITEM",
    		"COLUMN_REF",
    		"RUNTIME_FRAME_OPTIONS",
    		"RUNTIME_BROWSE_OPTIONS",
    		"PARENT_CHILD_RELATION",
    		"DATA_SET",
    		"DATA_SOURCE",
    		"DATA_RELATION",
    		"PARENT_ID_RELATION",
    		"LANGUAGES",
    		"DYNAMIC",
    		"MINUS",
    		"PLUS",
    		"UN_MINUS",
    		"UN_PLUS",
    		"BITWISE_OR",
    		"BITWISE_AND",
    		"BITWISE_NOT",
    		"BITWISE_XOR",
    		"BOOL_TRUE",
    		"BOOL_FALSE",
    		"DEC_LITERAL",
    		"DATE_LITERAL",
    		"DATETIME_LITERAL",
    		"DATETIME_TZ_LITERAL",
    		"HEX_LITERAL",
    		"UNQUOTED_TEXT",
    		"NO_LOCK_LITERAL",
    		"SHARE_LOCK_LITERAL",
    		"EXCLUSIVE_LOCK_LITERAL",
    		"NO_WAIT_LITERAL",
    		"READ_AVAILABLE_LITERAL",
    		"READ_EXACT_NUM_LITERAL",
    		"SEARCH_SELF_LITERAL",
    		"SEARCH_TARGET_LITERAL",
    		"PROC_CALL_TYPE_LITERAL",
    		"FUNC_CALL_TYPE_LITERAL",
    		"GET_ATTR_CTYPE_LITERAL",
    		"SET_ATTR_CTYPE_LITERAL",
    		"DLL_CALL_TYPE_LITERAL",
    		"OPTION",
    		"COM_METHOD",
    		"COM_PROPERTY",
    		"COM_PARAMETER",
    		"COM_INVOCATION",
    		"ENUM_VALUE",
    		"FILTER_SPEC",
    		"SUPPORT_LVL_NONE",
    		"SUPPORT_LVL_PARTIAL",
    		"SUPPORT_LVL_FULL_WITH_LIMITATIONS",
    		"SUPPORT_LVL_FULL",
    		"BOGUS",
    		"STATIC_WRAPPER",
    		"FRAME_LOCK",
    		"FRAME_UNLOCK",
    		"BEGIN_MULTIWORD",
    		"ALTER_TABLE",
    		"AS_BUTTON",
    		"CLOSE_QUERY",
    		"CLOSE_CURSOR",
    		"CLOSE_STORED_PROCEDURE",
    		"CREATE_ALIAS",
    		"CREATE_BROWSE",
    		"CREATE_BUFFER",
    		"CREATE_CALL",
    		"CREATE_CLIENT_PRINCIPAL",
    		"CREATE_OBJECT",
    		"CREATE_DATABASE",
    		"CREATE_DATASET",
    		"CREATE_DATA_SOURCE",
    		"CREATE_INDEX",
    		"CREATE_QUERY",
    		"CREATE_SAX_ATTRIBUTES",
    		"CREATE_SAX_READER",
    		"CREATE_SAX_WRITER",
    		"CREATE_SERVER",
    		"CREATE_SRV_SOCKET",
    		"CREATE_SOAP_HEADER",
    		"CREATE_SOAP_HEADER_ENTRYREF",
    		"CREATE_SOCKET",
    		"CREATE_TABLE",
    		"CREATE_TEMP_TABLE",
    		"CREATE_VIEW",
    		"CREATE_WIDGET",
    		"CREATE_WIDGET_POOL",
    		"CREATE_X_DOCUMENT",
    		"CREATE_X_NODEREF",
    		"DDE_ADVISE",
    		"DDE_EXECUTE",
    		"DDE_GET",
    		"DDE_INITIATE",
    		"DDE_REQUEST",
    		"DDE_SEND",
    		"DDE_TERMINATE",
    		"DECLARE_CURSOR",
    		"DEFINE_BROWSE",
    		"DEFINE_BUFFER",
    		"DEFINE_BUTTON",
    		"DEFINE_DATASET",
    		"DEFINE_DATA_SOURCE",
    		"DEFINE_ENUM",
    		"DEFINE_EVENT",
    		"DEFINE_FIELD",
    		"DEFINE_FRAME",
    		"DEFINE_IMAGE",
    		"DEFINE_MENU",
    		"DEFINE_PARAMETER",
    		"DEFINE_PROPERTY",
    		"DEFINE_QUERY",
    		"DEFINE_RECTANGLE",
    		"DEFINE_STREAM",
    		"DEFINE_SUB_MENU",
    		"DEFINE_TEMP_TABLE",
    		"DEFINE_VARIABLE",
    		"DEFINE_WORK_TABLE",
    		"DELETE_ALIAS",
    		"DELETE_FROM",
    		"DELETE_OBJECT",
    		"DELETE_PROCEDURE",
    		"DELETE_WIDGET",
    		"DELETE_WIDGET_POOL",
    		"DISABLE_TRIGGERS",
    		"DROP_INDEX",
    		"DROP_TABLE",
    		"DROP_VIEW",
    		"EMPTY_TEMP_TABLE",
    		"GROUP_BY",
    		"IN_WIDGET_POOL",
    		"INNER_JOIN",
    		"INPUT_CLEAR",
    		"INPUT_CLOSE",
    		"INPUT_FROM",
    		"INPUT_THRU",
    		"INPUT_OUTPUT_CLOSE",
    		"INPUT_OUTPUT_THRU",
    		"INSERT_INTO",
    		"IS_NULL",
    		"IS_NOT_NULL",
    		"LEFT_OUTER_JOIN",
    		"OPEN_CURSOR",
    		"OPEN_QUERY",
    		"ORDER_BY",
    		"OUTPUT_CLOSE",
    		"OUTPUT_THRU",
    		"OUTPUT_TO",
    		"NOT_BETWEEN",
    		"NOT_ENTERED",
    		"NOT_EXISTS",
    		"NOT_IN",
    		"NOT_LIKE",
    		"NOT_NULL",
    		"PROCESS_EVENTS",
    		"PUT_CURSOR",
    		"PUT_SCREEN",
    		"RELEASE_EXTERNAL",
    		"RELEASE_OBJECT",
    		"RIGHT_OUTER_JOIN",
    		"RUN_SUPER",
    		"RUN_STORED_PROCEDURE",
    		"SAVE_CACHE",
    		"SYSTEM_DIALOG_COLOR",
    		"SYSTEM_DIALOG_FONT",
    		"SYSTEM_DIALOG_GET_DIR",
    		"SYSTEM_DIALOG_GET_FILE",
    		"SYSTEM_DIALOG_PRINTER_SETUP",
    		"TRANSACTION_DISTINCT",
    		"TRIGGER_PROCEDURE",
    		"TRANSACTION_MODE_AUTO",
    		"UPDATE_SQL",
    		"WHERE_CURRENT_OF",
    		"WITH_CHECK_OPTION",
    		"WITH_GRANT_OPTION",
    		"DATA_SOURCE_QUERY",
    		"DATA_SOURCE_BUFFER",
    		"END_MULTIWORD",
    		"BEGIN_FUNCTYPES",
    		"FUNC_CHAR",
    		"FUNC_CLASS",
    		"FUNC_COM_HANDLE",
    		"FUNC_DATE",
    		"FUNC_DATETIME",
    		"FUNC_DATETIME_TZ",
    		"FUNC_DEC",
    		"FUNC_INT",
    		"FUNC_INT64",
    		"FUNC_LOGICAL",
    		"FUNC_LONGCHAR",
    		"FUNC_RECID",
    		"FUNC_ROWID",
    		"FUNC_HANDLE",
    		"FUNC_RAW",
    		"FUNC_MEMPTR",
    		"FUNC_POLY",
    		"FUNC_VOID",
    		"END_FUNCTYPES",
    		"BEGIN_LVALUE",
    		"BEGIN_VARTYPES",
    		"VAR_CHAR",
    		"VAR_CLASS",
    		"VAR_COM_HANDLE",
    		"VAR_DATE",
    		"VAR_DATETIME",
    		"VAR_DATETIME_TZ",
    		"VAR_DEC",
    		"VAR_HANDLE",
    		"VAR_INT",
    		"VAR_INT64",
    		"VAR_LOGICAL",
    		"VAR_LONGCHAR",
    		"VAR_MEMPTR",
    		"VAR_RAW",
    		"VAR_RECID",
    		"VAR_ROWID",
    		"SYS_HANDLE",
    		"VAR_POLY",
    		"BEGIN_NATIVE_VARTYPES",
    		"VAR_BYTE",
    		"VAR_DOUBLE",
    		"VAR_FLOAT",
    		"VAR_LONG",
    		"VAR_SHORT",
    		"VAR_ULONG",
    		"VAR_USHORT",
    		"END_NATIVE_VARTYPES",
    		"END_VARTYPES",
    		"BEGIN_FIELDTYPES",
    		"FIELD_BLOB",
    		"FIELD_CHAR",
    		"FIELD_CLASS",
    		"FIELD_CLOB",
    		"FIELD_COM_HANDLE",
    		"FIELD_DATE",
    		"FIELD_DATETIME",
    		"FIELD_DATETIME_TZ",
    		"FIELD_DEC",
    		"FIELD_INT",
    		"FIELD_INT64",
    		"FIELD_LOGICAL",
    		"FIELD_RECID",
    		"FIELD_ROWID",
    		"FIELD_HANDLE",
    		"FIELD_RAW",
    		"END_FIELDTYPES",
    		"BEGIN_WIDGETS",
    		"WID_BROWSE",
    		"WID_BROWSE_COL",
    		"WID_BUTTON",
    		"WID_COMBO",
    		"WID_DIALOG",
    		"WID_EDITOR",
    		"WID_FILL_IN",
    		"WID_FRAME",
    		"WID_IMAGE",
    		"WID_LITERAL",
    		"WID_MENU",
    		"WID_MENU_ITM",
    		"WID_RADIO",
    		"WID_RECT",
    		"WID_SEL_LST",
    		"WID_SLIDER",
    		"WID_SUB_MENU",
    		"WID_TEXT",
    		"WID_TOGGLE",
    		"WID_WINDOW",
    		"END_WIDGETS",
    		"STREAM",
    		"END_LVALUE",
    		"BEGIN_ATTR_METH",
    		"BEGIN_ATTR",
    		"ATTR_CHAR",
    		"ATTR_CLASS",
    		"ATTR_COM_HANDLE",
    		"ATTR_DATE",
    		"ATTR_DATETIME",
    		"ATTR_DATETIME_TZ",
    		"ATTR_DEC",
    		"ATTR_HANDLE",
    		"ATTR_INT",
    		"ATTR_INT64",
    		"ATTR_LOGICAL",
    		"ATTR_LONGCHAR",
    		"ATTR_MEMPTR",
    		"ATTR_RAW",
    		"ATTR_RECID",
    		"ATTR_ROWID",
    		"ATTR_POLY",
    		"END_ATTR",
    		"BEGIN_METH",
    		"METH_CHAR",
    		"METH_CLASS",
    		"METH_COM_HANDLE",
    		"METH_DATE",
    		"METH_DATETIME",
    		"METH_DATETIME_TZ",
    		"METH_DEC",
    		"METH_HANDLE",
    		"METH_INT",
    		"METH_INT64",
    		"METH_LOGICAL",
    		"METH_LONGCHAR",
    		"METH_MEMPTR",
    		"METH_POLY",
    		"METH_RAW",
    		"METH_RECID",
    		"METH_ROWID",
    		"METH_VOID",
    		"END_METH",
    		"END_ATTR_METH",
    		"BEGIN_OO_METH",
    		"OO_METH_CHAR",
    		"OO_METH_CLASS",
    		"OO_METH_COM_HANDLE",
    		"OO_METH_DATE",
    		"OO_METH_DATETIME",
    		"OO_METH_DATETIME_TZ",
    		"OO_METH_DEC",
    		"OO_METH_HANDLE",
    		"OO_METH_INT",
    		"OO_METH_INT64",
    		"OO_METH_LOGICAL",
    		"OO_METH_LONGCHAR",
    		"OO_METH_MEMPTR",
    		"OO_METH_RAW",
    		"OO_METH_RECID",
    		"OO_METH_ROWID",
    		"OO_METH_POLY",
    		"OO_METH_VOID",
    		"END_OO_METH",
    		"BEGIN_RESERVED",
    		"KW_U_CTRL",
    		"KW_U_MSG",
    		"KW_U_PCTRL",
    		"KW_U_SERIAL",
    		"KW_ACCUM",
    		"KW_ADD",
    		"KW_ASCEND",
    		"KW_ASC",
    		"KW_ACT_FORM",
    		"KW_ACT_WIN",
    		"KW_ALIAS",
    		"KW_ALL",
    		"KW_ALTER",
    		"KW_AMBIG",
    		"KW_ANALYZ",
    		"KW_AND",
    		"KW_ANY",
    		"KW_APPLY",
    		"KW_AS",
    		"KW_ASYNC",
    		"KW_ASSIGN",
    		"KW_AT",
    		"KW_ATTR",
    		"KW_AUD_CTRL",
    		"KW_AUD_POL",
    		"KW_AUTHORZN",
    		"KW_AUTO_RET",
    		"KW_AVAIL",
    		"KW_B_ENDIAN",
    		"KW_BACKGRND",
    		"KW_B4_HIDE",
    		"KW_BEGINS",
    		"KW_BELL",
    		"KW_BETWEEN",
    		"KW_BLANK",
    		"KW_BREAK",
    		"KW_BTOS",
    		"KW_BUF_COMP",
    		"KW_BUF_COPY",
    		"KW_BY",
    		"KW_CALL",
    		"KW_CAN_DO",
    		"KW_CAN_FIND",
    		"KW_CASE",
    		"KW_CASE_SEN",
    		"KW_CAST",
    		"KW_CENTER",
    		"KW_CHR",
    		"KW_CHECK",
    		"KW_CLEAR",
    		"KW_CLIP",
    		"KW_CODEBASE",
    		"KW_COL_LAB",
    		"KW_COLON",
    		"KW_COLOR",
    		"KW_COLUMNS",
    		"KW_COMPILER",
    		"KW_CONN_ED",
    		"KW_CONTROL",
    		"KW_COUNT_OF",
    		"KW_CPY_LOB",
    		"KW_CREATE",
    		"KW_CTOS",
    		"KW_CURRENT",
    		"KW_CUR_CHG",
    		"KW_CUR_LANG",
    		"KW_CUR_WIN",
    		"KW_CURSOR",
    		"KW_DATA_SRC",
    		"KW_DATABASE",
    		"KW_DATASRV",
    		"KW_DATASET",
    		"KW_DB_CTXT",
    		"KW_DB_REF",
    		"KW_DB_REM_H",
    		"KW_DBCP",
    		"KW_DBCOLL",
    		"KW_DBNAME",
    		"KW_DBPARAM",
    		"KW_DBREST",
    		"KW_DBTASKID",
    		"KW_DBTYPE",
    		"KW_DBVERS",
    		"KW_DDE",
    		"KW_DEBLANK",
    		"KW_DEBUGGER",
    		"KW_DBG_LST",
    		"KW_DECIMALS",
    		"KW_DECLARE",
    		"KW_DEFAULT",
    		"KW_DEF_NOXL",
    		"KW_DEF_WIN",
    		"KW_DEFINE",
    		"KW_DELETE",
    		"KW_DELIMIT",
    		"KW_DESCEND",
    		"KW_DICT",
    		"KW_DISABLE",
    		"KW_DIS_A_ZA",
    		"KW_DISCONN",
    		"KW_DISP",
    		"KW_DISTINCT",
    		"KW_DLL_C_T",
    		"KW_DO",
    		"KW_DOS",
    		"KW_DOWN",
    		"KW_DROP",
    		"KW_DSET_HND",
    		"KW_DSL_MGR",
    		"KW_DYN_ENUM",
    		"KW_DYN_FUNC",
    		"KW_DYN_INVK",
    		"KW_DYN_NEW",
    		"KW_DYN_PROP",
    		"KW_EACH",
    		"KW_EDITING",
    		"KW_ELSE",
    		"KW_ENABLE",
    		"KW_ENCODE",
    		"KW_END",
    		"KW_ENTRY",
    		"KW_ERR_STAT",
    		"KW_ESCAPE",
    		"KW_EVT_PROC",
    		"KW_EXC_LOCK",
    		"KW_EXISTS",
    		"KW_ETIME",
    		"KW_EXCEPT",
    		"KW_EXPORT",
    		"KW_FETCH",
    		"KW_FIELD",
    		"KW_FIL_INFO",
    		"KW_FILL",
    		"KW_FIND",
    		"KW_FIND_CS",
    		"KW_FIND_GLO",
    		"KW_FIND_NO",
    		"KW_FIND_PO",
    		"KW_FIND_SEL",
    		"KW_FIND_WA",
    		"KW_FIRST",
    		"KW_FIRST_OF",
    		"KW_FOCUS",
    		"KW_FONT",
    		"KW_FOR",
    		"KW_FORM",
    		"KW_FORMAT",
    		"KW_FRAME",
    		"KW_FR_COL",
    		"KW_FR_DB",
    		"KW_FR_DOWN",
    		"KW_FR_FIELD",
    		"KW_FR_FILE",
    		"KW_FR_INDEX",
    		"KW_FR_LINE",
    		"KW_FR_NAME",
    		"KW_FR_ROW",
    		"KW_FR_VAL",
    		"KW_FROM",
    		"KW_FROM_CHR",
    		"KW_FROM_PIX",
    		"KW_FUNC_C_T",
    		"KW_FWD_DRIV",
    		"KW_GW",
    		"KW_GET_A_CT",
    		"KW_GET_BUFH",
    		"KW_GET_BYTE",
    		"KW_GET_CODP",
    		"KW_GET_COLL",
    		"KW_GET_ERRC",
    		"KW_GET_ERRR",
    		"KW_GET_FNAM",
    		"KW_GET_FOFF",
    		"KW_GET_K_V",
    		"KW_GLOBAL",
    		"KW_GO_ON",
    		"KW_GO_PEND",
    		"KW_GRANT",
    		"KW_GRAPHIC",
    		"KW_GROUP",
    		"KW_HASHCODE",
    		"KW_HEADER",
    		"KW_HAVING",
    		"KW_HELP",
    		"KW_HIDE",
    		"KW_HOST_B_O",
    		"KW_IF",
    		"KW_IMPORT",
    		"KW_IN",
    		"KW_INDEX",
    		"KW_INDICAT",
    		"KW_INPUT",
    		"KW_IN_OUT",
    		"KW_INSERT",
    		"KW_INTO",
    		"KW_IS",
    		"KW_IS_ATTR",
    		"KW_IS_LEAD",
    		"KW_JOIN",
    		"KW_KBLABEL",
    		"KW_KEYCODE",
    		"KW_KEYFUNC",
    		"KW_KEYLAB",
    		"KW_KEYS",
    		"KW_KW",
    		"KW_L_ENDIAN",
    		"KW_LABEL",
    		"KW_LAST",
    		"KW_LASTKEY",
    		"KW_LAST_EVT",
    		"KW_LAST_OF",
    		"KW_LDBNAME",
    		"KW_LEAVE",
    		"KW_LIB",
    		"KW_LIKE",
    		"KW_LINE_CNT",
    		"KW_LISTING",
    		"KW_LOCKED",
    		"KW_LOG_MGR",
    		"KW_LOOKUP",
    		"KW_MACH_CLS",
    		"KW_MAP",
    		"KW_MEMBER",
    		"KW_MOUSE",
    		"KW_MPE",
    		"KW_MSG",
    		"KW_MSG_LINE",
    		"KW_NEW",
    		"KW_NEXT",
    		"KW_NEXT_PMT",
    		"KW_NO_ATTR",
    		"KW_NO_ATTRL",
    		"KW_NO_ERROR",
    		"KW_NO_FILL",
    		"KW_NO_FOCUS",
    		"KW_NO_HIDE",
    		"KW_NO_LABEL",
    		"KW_NO_LOBS",
    		"KW_NO_LOCK",
    		"KW_NO_MAP",
    		"KW_NO_MSG",
    		"KW_NO_PAUSE",
    		"KW_NO_PRE",
    		"KW_NO_RET_V",
    		"KW_NO_UNDO",
    		"KW_NO_VALID",
    		"KW_NO_WAIT",
    		"KW_NOT",
    		"KW_NOW",
    		"KW_NULL",
    		"KW_NUM_ALIA",
    		"KW_NUM_DBS",
    		"KW_NUM_ENT",
    		"KW_OF",
    		"KW_OFF",
    		"KW_OLD",
    		"KW_ON",
    		"KW_OPEN",
    		"KW_OR",
    		"KW_OUTPUT",
    		"KW_OPSYS",
    		"KW_OPTION",
    		"KW_OS2",
    		"KW_OS_APPND",
    		"KW_OS_COPY",
    		"KW_OS_CMD",
    		"KW_OS_MKDIR",
    		"KW_OS_DEL",
    		"KW_OS_DIR",
    		"KW_OS_REN",
    		"KW_OTHER",
    		"KW_OVERLAY",
    		"KW_PAGE",
    		"KW_PAGE_B",
    		"KW_PAGE_NUM",
    		"KW_PAGE_T",
    		"KW_PARM",
    		"KW_PASSWD_F",
    		"KW_PAUSE",
    		"KW_PDBNAME",
    		"KW_PERSIST",
    		"KW_PIXELS",
    		"KW_PREPROC",
    		"KW_PRIVILEG",
    		"KW_PROCESS",
    		"KW_PROC_C_T",
    		"KW_PROC_HND",
    		"KW_PROC_ST",
    		"KW_PROFILER",
    		"KW_PROGNAME",
    		"KW_PROGRESS",
    		"KW_PROMPT",
    		"KW_PRMT_FOR",
    		"KW_PROMSGS",
    		"KW_PROPATH",
    		"KW_PROVER",
    		"KW_PUBLISH",
    		"KW_PUT",
    		"KW_PUT_BYTE",
    		"KW_PUT_K_V",
    		"KW_QUERY",
    		"KW_QRY_CLOS",
    		"KW_QRY_OFF",
    		"KW_QRY_TUNE",
    		"KW_QUIT",
    		"KW_R_INDEX",
    		"KW_RCOD_INF",
    		"KW_READ_AVL",
    		"KW_READ_E_N",
    		"KW_READKEY",
    		"KW_RECID",
    		"KW_RECT",
    		"KW_RELEASE",
    		"KW_REPEAT",
    		"KW_REPL_CRE",
    		"KW_REPL_DEL",
    		"KW_REPL_WRI",
    		"KW_REPOS",
    		"KW_REPOS_B",
    		"KW_REPOS_F",
    		"KW_REPOS_2R",
    		"KW_REPOS_2I",
    		"KW_RETAIN",
    		"KW_RETRY",
    		"KW_RETURN",
    		"KW_REVERT",
    		"KW_REVOKE",
    		"KW_ROW_CRTD",
    		"KW_ROW_DELD",
    		"KW_ROW_MODD",
    		"KW_ROW_UMOD",
    		"KW_RTOPSYS",
    		"KW_RUN",
    		"KW_SAVE",
    		"KW_SAX_COMP",
    		"KW_SAX_PARE",
    		"KW_SAX_RUNN",
    		"KW_SAX_UNIN",
    		"KW_SAX_WBEG",
    		"KW_SAX_WCOM",
    		"KW_SAX_WCON",
    		"KW_SAX_WELM",
    		"KW_SAX_WERR",
    		"KW_SAX_WIDL",
    		"KW_SAX_WTAG",
    		"KW_SCHEMA",
    		"KW_SCREEN",
    		"KW_SCRN_IO",
    		"KW_SCRN_LNS",
    		"KW_SCROLL",
    		"KW_SDBNAME",
    		"KW_SEAR_SLF",
    		"KW_SEAR_TRG",
    		"KW_SEARCH",
    		"KW_SECUR_P",
    		"KW_SEEK",
    		"KW_SELECT",
    		"KW_SELF",
    		"KW_SESSION",
    		"KW_SET",
    		"KW_SET_A_CT",
    		"KW_SETUSER",
    		"KW_SH_LOCK",
    		"KW_SHARED",
    		"KW_SHOW_ST",
    		"KW_SING_RUN",
    		"KW_SKIP",
    		"KW_SKIP_D_R",
    		"KW_SOME",
    		"KW_SPACE",
    		"KW_STATUS",
    		"KW_STREAM",
    		"KW_STRM_HND",
    		"KW_STRM_IO",
    		"KW_SUBSCRIB",
    		"KW_SUPER",
    		"KW_SYS_DLG",
    		"KW_TABLE",
    		"KW_TAB_NUM",
    		"KW_TERM",
    		"KW_TEXT",
    		"KW_THEN",
    		"KW_THIS_OBJ",
    		"KW_THIS_PRC",
    		"KW_TIME",
    		"KW_TITLE",
    		"KW_TO",
    		"KW_TOP_ONLY",
    		"KW_TO_ROWID",
    		"KW_TRANS",
    		"KW_TRIGGER",
    		"KW_TRIGGERS",
    		"KW_TRIM",
    		"KW_TXT_CURS",
    		"KW_UNDO",
    		"KW_UNION",
    		"KW_UNIQUE",
    		"KW_UNIX",
    		"KW_UNDERLIN",
    		"KW_UNFORMAT",
    		"KW_UNSUBSCR",
    		"KW_UP",
    		"KW_UPDATE",
    		"KW_USE_IDX",
    		"KW_USERID",
    		"KW_USING",
    		"KW_V6FRAME",
    		"KW_VALUE",
    		"KW_VAL_CHG",
    		"KW_VALUES",
    		"KW_VIEW",
    		"KW_VIEW_AS",
    		"KW_VMS",
    		"KW_WAIT_FOR",
    		"KW_WHEN",
    		"KW_WHERE",
    		"KW_WHILE",
    		"KW_WINDOW",
    		"KW_WIN_DMIN",
    		"KW_WIN_MAX",
    		"KW_WIN_MIN",
    		"KW_WIN_NORM",
    		"KW_WITH",
    		"KW_WORK_TAB",
    		"KW_WRITE",
    		"KW_XCODE",
    		"KW_XOR",
    		"KW_XREF",
    		"KW_XREF_XML",
    		"END_RESERVED",
    		"BEGIN_UNRESERVED",
    		"KW_ABORT",
    		"KW_ABS",
    		"KW_ABSTRACT",
    		"KW_ACC_CHG",
    		"KW_ACC_RCHG",
    		"KW_ACCEL",
    		"KW_ACTIVE",
    		"KW_ACTOR",
    		"KW_ADD_BUF",
    		"KW_ADD_C_C",
    		"KW_ADD_C_F",
    		"KW_ADD_EVTP",
    		"KW_ADD_F_F",
    		"KW_ADD_1ST",
    		"KW_ADD_HENT",
    		"KW_ADD_INVL",
    		"KW_ADD_IDXF",
    		"KW_ADD_LAST",
    		"KW_ADD_L_C",
    		"KW_ADD_LIKF",
    		"KW_ADD_LIKI",
    		"KW_ADD_NEWF",
    		"KW_ADD_NEWI",
    		"KW_ADD_PREL",
    		"KW_ADD_REL",
    		"KW_ADD_SLOC",
    		"KW_ADD_SRCB",
    		"KW_ADD_SUP",
    		"KW_ADM_DATA",
    		"KW_ADM_TO",
    		"KW_ADVISE",
    		"KW_AFT_BUFF",
    		"KW_AFT_FILL",
    		"KW_AFT_R_F",
    		"KW_AFT_ROID",
    		"KW_AFT_TBL",
    		"KW_ALERT_BX",
    		"KW_ALIGN",
    		"KW_ALLW_C_S",
    		"KW_ALLW_REP",
    		"KW_ALT_KEY",
    		"KW_ALW_ON_T",
    		"KW_ANSI_ONL",
    		"KW_ANY_KEY",
    		"KW_ANY_PRT",
    		"KW_ANYWHERE",
    		"KW_APPEND",
    		"KW_APPEND_C",
    		"KW_APPEND_L",
    		"KW_APPL_A_B",
    		"KW_APPL",
    		"KW_APPL_CID",
    		"KW_APPL_CBK",
    		"KW_APP_INFO",
    		"KW_APP_PW",
    		"KW_APP_UID",
    		"KW_ARR_MSG",
    		"KW_ASCII_2H",
    		"KW_ASK_OVER",
    		"KW_ASSEMBLY",
    		"KW_ASYNC_RC",
    		"KW_ASYNC_RH",
    		"KW_ATT_DSRC",
    		"KW_ATT_PLST",
    		"KW_ATTR_NAM",
    		"KW_AUD_ENAB",
    		"KW_AUD_EV_C",
    		"KW_AUTHBLOB",
    		"KW_AUTHEN_F",
    		"KW_AUTO_COM",
    		"KW_AUTO_DEL",
    		"KW_AUTO_D_X",
    		"KW_AUTO_END",
    		"KW_AUTO_GO",
    		"KW_AUTO_IND",
    		"KW_AUTO_RES",
    		"KW_AUTO_SYN",
    		"KW_AUTO_VAL",
    		"KW_AUTO_ZAP",
    		"KW_AUTOMATC",
    		"KW_AVERAGE",
    		"KW_AVG",
    		"KW_AVL_FMTS",
    		"KW_AVL_MSGS",
    		"KW_BACKSP",
    		"KW_BACKWARD",
    		"KW_BACK_TAB",
    		"KW_BAS_LOGG",
    		"KW_BASE64_D",
    		"KW_BASE64_E",
    		"KW_BASE_ADE",
    		"KW_BASE_KEY",
    		"KW_BATCH_MO",
    		"KW_BATCH_SZ",
    		"KW_B4_BUFF",
    		"KW_B4_FILL",
    		"KW_B4_R_F",
    		"KW_B4_ROWID",
    		"KW_B4_TABLE",
    		"KW_BEG_EV_G",
    		"KW_BGCOLOR",
    		"KW_BGCOLRGB",
    		"KW_BINARY",
    		"KW_BIND",
    		"KW_BIND_WH",
    		"KW_BLOB",
    		"KW_BLOCK",
    		"KW_BLK_LVL",
    		"KW_BLK_IT_D",
    		"KW_BORD_B_C",
    		"KW_BORD_B_P",
    		"KW_BORD_L_C",
    		"KW_BORD_L_P",
    		"KW_BORD_R_C",
    		"KW_BORD_R_P",
    		"KW_BORD_T_C",
    		"KW_BORD_T_P",
    		"KW_BOTH",
    		"KW_BOTTOM",
    		"KW_BOTTOM_C",
    		"KW_BOX",
    		"KW_BOX_SEL",
    		"KW_BR_AGENT",
    		"KW_BR_IP",
    		"KW_BR_PORT",
    		"KW_BR_TZ",
    		"KW_BREAK_L",
    		"KW_BROWSE",
    		"KW_BUFFER",
    		"KW_BUFFER_C",
    		"KW_BUF_CREA",
    		"KW_BUF_DEL",
    		"KW_BUF_FLD",
    		"KW_BUF_GRPI",
    		"KW_BUF_GRPN",
    		"KW_BUF_HNDL",
    		"KW_BUF_NAME",
    		"KW_BUF_PARI",
    		"KW_BUFFER_L",
    		"KW_BUF_REL",
    		"KW_BUF_TENI",
    		"KW_BUF_TENN",
    		"KW_BUF_VLID",
    		"KW_BUF_VAL",
    		"KW_BUTTON",
    		"KW_BY_PTR",
    		"KW_BY_REF",
    		"KW_BY_VALUE",
    		"KW_BY_VAR_P",
    		"KW_BYTE",
    		"KW_BYTES_R",
    		"KW_BYTES_W",
    		"KW_CACHE",
    		"KW_CACHE_SZ",
    		"KW_CALL_NAM",
    		"KW_CALL_TYP",
    		"KW_CANC_BRK",
    		"KW_CANCEL_B",
    		"KW_CANCEL_P",
    		"KW_CANCEL_R",
    		"KW_CANCELLD",
    		"KW_CAN_CREA",
    		"KW_CAN_DEL",
    		"KW_CAN_DUMP",
    		"KW_CAN_LOAD",
    		"KW_CAN_QRY",
    		"KW_CAN_READ",
    		"KW_CAN_SET",
    		"KW_CAN_WRT",
    		"KW_CAPS",
    		"KW_CARE_PNT",
    		"KW_CBIT",
    		"KW_CATCH",
    		"KW_CDECL",
    		"KW_CFG_NAME",
    		"KW_CHAINED",
    		"KW_CHAR",
    		"KW_CHAR_LEN",
    		"KW_CHARSET",
    		"KW_CHART",
    		"KW_CHECKED",
    		"KW_CHECK_AM",
    		"KW_CHLD_BUF",
    		"KW_CHLD_NUM",
    		"KW_CHOICES",
    		"KW_CHOOSE",
    		"KW_CLASS",
    		"KW_CLN_IP",
    		"KW_CLN_PORT",
    		"KW_CLN_TZ",
    		"KW_CLN_TIME",
    		"KW_CLOB",
    		"KW_CLR_SEL",
    		"KW_CLR_AP_C",
    		"KW_CLR_LOG",
    		"KW_CLR_S_AR",
    		"KW_CLS_TYPE",
    		"KW_CLNT_C_I",
    		"KW_CLNT_DIS",
    		"KW_CLNT_PRL",
    		"KW_CLNT_TTY",
    		"KW_CLNT_TYP",
    		"KW_CLNT_WS",
    		"KW_CLONE_ND",
    		"KW_CLOSE",
    		"KW_CLOSE_AP",
    		"KW_CLOSE_LG",
    		"KW_CNCL_R_A",
    		"KW_CNTRL_BX",
    		"KW_CODE",
    		"KW_CP_CVT",
    		"KW_CP",
    		"KW_COLLATE",
    		"KW_COLON_AL",
    		"KW_COLR_TAB",
    		"KW_COL",
    		"KW_COL_BGC",
    		"KW_COL_CP",
    		"KW_COL_DC",
    		"KW_COL_FGC",
    		"KW_COL_FONT",
    		"KW_COL_MOV",
    		"KW_COL_PFC",
    		"KW_COL_OF",
    		"KW_COL_R_O",
    		"KW_COL_RES",
    		"KW_COL_SCR",
    		"KW_COM_HNDL",
    		"KW_COM_SELF",
    		"KW_COMBO_BX",
    		"KW_COMMAND",
    		"KW_COMPARE",
    		"KW_COMPARES",
    		"KW_COMPILE",
    		"KW_COMPLETE",
    		"KW_CONN",
    		"KW_CONSTRUC",
    		"KW_CTX",
    		"KW_CTX_H",
    		"KW_CTX_H_F",
    		"KW_CTX_H_ID",
    		"KW_CTX_POP",
    		"KW_CONTAINS",
    		"KW_CONTENTS",
    		"KW_CNTRL_FR",
    		"KW_CNTRL_NM",
    		"KW_CONTROLS",
    		"KW_CVT_DT",
    		"KW_CONVERT",
    		"KW_CVT_2OFF",
    		"KW_CVT_3D_C",
    		"KW_COOKIE_D",
    		"KW_COPY",
    		"KW_CPY_DSET",
    		"KW_CPY_SATR",
    		"KW_CPY_TTBL",
    		"KW_COUNT",
    		"KW_COVERAGE",
    		"KW_CPCASE",
    		"KW_CPCOLL",
    		"KW_CPINTERN",
    		"KW_CPLOG",
    		"KW_CPPRINT",
    		"KW_CPRCODEI",
    		"KW_CPRCODEO",
    		"KW_CPSTREAM",
    		"KW_CPTERM",
    		"KW_CRC_VAL",
    		"KW_CREAT_LK",
    		"KW_CR_LK_SQ",
    		"KW_CREAT_OA",
    		"KW_CREAT_ND",
    		"KW_CREAT_NN",
    		"KW_CREAT_RL",
    		"KW_CREAT_TF",
    		"KW_CURRENCY",
    		"KW_CUR_COL",
    		"KW_CUR_DATE",
    		"KW_CUR_QRY",
    		"KW_CUR_RES",
    		"KW_CUR_RQI",
    		"KW_CUR_RSI",
    		"KW_CUR_R_M",
    		"KW_CUR_VAL",
    		"KW_CUR_CHAR",
    		"KW_CUR_ENV",
    		"KW_CUR_DOWN",
    		"KW_CUR_ITER",
    		"KW_CUR_LEFT",
    		"KW_CUR_LINE",
    		"KW_CUR_OFF",
    		"KW_CUR_RGHT",
    		"KW_CUR_UP",
    		"KW_CUT",
    		"KW_DATA_BND",
    		"KW_DATA_E_R",
    		"KW_DATA_REL",
    		"KW_DATA_SCM",
    		"KW_DATA_SM",
    		"KW_DATA_SRI",
    		"KW_DATATYPE",
    		"KW_DATE",
    		"KW_DATETIME",
    		"KW_DATE_TZ",
    		"KW_DATE_FMT",
    		"KW_DAY",
    		"KW_DB_JOIN",
    		"KW_DB_LIST",
    		"KW_DCOLOR",
    		"KW_DDE_ERR",
    		"KW_DDE_ID",
    		"KW_DDE_ITEM",
    		"KW_DDE_NAME",
    		"KW_DDE_NOTI",
    		"KW_DDE_TOPI",
    		"KW_DEBUG",
    		"KW_DECRYPT",
    		"KW_DBG_ALRT",
    		"KW_DE_REGIS",
    		"KW_DEC",
    		"KW_DECL_NSP",
    		"KW_DEF_ACTN",
    		"KW_DEFLT_BN",
    		"KW_DEF_BUFH",
    		"KW_DEF_COMM",
    		"KW_DEF_EXTN",
    		"KW_DEF_STR",
    		"KW_DEF_POP",
    		"KW_DEF_VAL",
    		"KW_DEF_UEVM",
    		"KW_DELEGATE",
    		"KW_DEL_CHAR",
    		"KW_DEL_COL",
    		"KW_DEL_COOK",
    		"KW_DEL_C_R",
    		"KW_DEL_E_L",
    		"KW_DEL_FLD",
    		"KW_DEL_H_EN",
    		"KW_DEL_LINE",
    		"KW_DEL_NODE",
    		"KW_DEL_PROC",
    		"KW_DEL_R_L",
    		"KW_DEL_S_C",
    		"KW_DEL_S_R",
    		"KW_DEL_S_RS",
    		"KW_DEL_WORD",
    		"KW_DESCR",
    		"KW_DESEL_FR",
    		"KW_DESEL_R",
    		"KW_DESEL_SR",
    		"KW_DESELCTN",
    		"KW_DESTRUCT",
    		"KW_DET_DSRC",
    		"KW_DEVICEID",
    		"KW_DIALOG",
    		"KW_DIR",
    		"KW_DIRECTRY",
    		"KW_DIS_D_TR",
    		"KW_DIS_L_TR",
    		"KW_DIS_REDR",
    		"KW_DISABL_C",
    		"KW_DISABLED",
    		"KW_DISPATCH",
    		"KW_DISP_MSG",
    		"KW_DISP_TZ",
    		"KW_DISP_TYP",
    		"KW_DOMAIN_D",
    		"KW_DOMAIN_N",
    		"KW_DOMAIN_T",
    		"KW_DOUBLE",
    		"KW_DRAG_EN",
    		"KW_DROP_DWN",
    		"KW_DROP_FN",
    		"KW_DROP_LST",
    		"KW_DROP_TAR",
    		"KW_DUMP",
    		"KW_DUMP_LGN",
    		"KW_DYN_CAST",
    		"KW_DYN_CURV",
    		"KW_DYN_NEXV",
    		"KW_DYNAMIC",
    		"KW_ECHO",
    		"KW_EDGE_C",
    		"KW_EDGE_P",
    		"KW_EDIT_C_P",
    		"KW_EDIT_C_U",
    		"KW_EDIT_CLR",
    		"KW_EDIT_CPY",
    		"KW_EDIT_CUT",
    		"KW_EDIT_PAS",
    		"KW_EDIT_UND",
    		"KW_EDITOR",
    		"KW_EDIT_B_T",
    		"KW_EDIT_TAB",
    		"KW_EH_FL",
    		"KW_EH_SR",
    		"KW_NO_EMBED",
    		"KW_EMPTY",
    		"KW_EMPTY_DS",
    		"KW_EMPTY_SN",
    		"KW_EMPTY_TT",
    		"KW_ENABLE_C",
    		"KW_ENABLE_E",
    		"KW_ENC_AMK",
    		"KW_ENC_SALT",
    		"KW_ENCODING",
    		"KW_ENCRYPT",
    		"KW_END_B_SN",
    		"KW_END_DOC",
    		"KW_END_ELEM",
    		"KW_END_EV_G",
    		"KW_END_SEAR",
    		"KW_END_USER",
    		"KW_END_ERR",
    		"KW_END_F_D",
    		"KW_END_MOV",
    		"KW_END_RESZ",
    		"KW_END_RRES",
    		"KW_ENDKEY",
    		"KW_ENT_TLST",
    		"KW_ENUM",
    		"KW_ENTERED",
    		"KW_ENTER_MB",
    		"KW_ENT_EX_L",
    		"KW_ERROR",
    		"KW_ERR_CODE",
    		"KW_ERR_COL",
    		"KW_ERR_OBJD",
    		"KW_ERR_ROW",
    		"KW_ERR_S_T",
    		"KW_ERR_STR",
    		"KW_EQ",
    		"KW_EVENTS",
    		"KW_EVT_GRID",
    		"KW_EVT_TYPE",
    		"KW_E_PROC_C",
    		"KW_EXCL_ID",
    		"KW_EXCL_WEB",
    		"KW_EXECUTE",
    		"KW_EXEC_LOG",
    		"KW_EXIT",
    		"KW_EXITCODE",
    		"KW_EXP",
    		"KW_EXPAND",
    		"KW_EXPANDBL",
    		"KW_EXPORT_P",
    		"KW_EXPLICIT",
    		"KW_EXTENDED",
    		"KW_EXTENT",
    		"KW_EXTERN",
    		"KW_FETCH_SR",
    		"KW_FGCOLOR",
    		"KW_FGCOLRGB",
    		"KW_FILE",
    		"KW_FIL_C_D",
    		"KW_FIL_C_T",
    		"KW_FIL_NAME",
    		"KW_FIL_OFF",
    		"KW_FIL_M_D",
    		"KW_FIL_M_T",
    		"KW_FIL_SIZE",
    		"KW_FIL_TYPE",
    		"KW_FILL_IN",
    		"KW_FILL_MOD",
    		"KW_FILL_WST",
    		"KW_FILLED",
    		"KW_FILTERS",
    		"KW_FINAL",
    		"KW_FINALLY",
    		"KW_FIND_BR",
    		"KW_FIND_CUR",
    		"KW_FIND_FD",
    		"KW_FIND_1ST",
    		"KW_FIND_LST",
    		"KW_FIND_NXT",
    		"KW_FIND_PRV",
    		"KW_FIND_UNI",
    		"KW_FINDER",
    		"KW_FIR_DSET",
    		"KW_FIRST_AR",
    		"KW_FIRST_BU",
    		"KW_FIRST_CH",
    		"KW_FIRST_CO",
    		"KW_FIRST_DS",
    		"KW_FIRST_FM",
    		"KW_FIRST_OB",
    		"KW_FIRST_PR",
    		"KW_FIRST_QR",
    		"KW_FIRST_SR",
    		"KW_FIRST_SS",
    		"KW_FIRST_SO",
    		"KW_FIRST_TI",
    		"KW_FIT_LCOL",
    		"KW_FIX_CP",
    		"KW_FIXD_ONL",
    		"KW_FLAGS",
    		"KW_FLAT_BUT",
    		"KW_FLOAT",
    		"KW_FONT_TAB",
    		"KW_FOCUS_R",
    		"KW_FOCUS_RS",
    		"KW_FORCE_F",
    		"KW_FORE",
    		"KW_F_KEY_H",
    		"KW_FORM_INP",
    		"KW_FORM_LIN",
    		"KW_FMT_DT",
    		"KW_FORMATTE",
    		"KW_FORWARD",
    		"KW_FRAGMENT",
    		"KW_FREQ",
    		"KW_FROM_CUR",
    		"KW_FR_SPACE",
    		"KW_FR_X",
    		"KW_FR_Y",
    		"KW_FUNCT",
    		"KW_FULL_H_C",
    		"KW_FULL_H_P",
    		"KW_FULL_W_C",
    		"KW_FULL_W_P",
    		"KW_FULLPATH",
    		"KW_FWD_LOGF",
    		"KW_FWD_ONLY",
    		"KW_GEN_MD5",
    		"KW_GEN_PBEK",
    		"KW_GEN_PBES",
    		"KW_GEN_RNDK",
    		"KW_GEN_UUID",
    		"KW_GET",
    		"KW_GETATTRI",
    		"KW_GET_ATTR",
    		"KW_GET_A_N",
    		"KW_GET_BDAT",
    		"KW_GET_BITS",
    		"KW_GET_B_OR",
    		"KW_GET_BLUE",
    		"KW_GET_BR_C",
    		"KW_GET_BYTS",
    		"KW_GET_B_A",
    		"KW_GET_CFG",
    		"KW_GET_CFGV",
    		"KW_GET_CBPC",
    		"KW_GET_CBPN",
    		"KW_GET_CGIL",
    		"KW_GET_CGIV",
    		"KW_GET_CGL",
    		"KW_GET_CGLV",
    		"KW_GET_CHG",
    		"KW_GET_CHLD",
    		"KW_GET_CLL",
    		"KW_GET_CLNT",
    		"KW_GET_CREL",
    		"KW_GET_CUR",
    		"KW_GET_DIR",
    		"KW_GET_DBCL",
    		"KW_GET_DBL",
    		"KW_GET_DS_B",
    		"KW_GET_D_E",
    		"KW_GET_D_F",
    		"KW_GET_DYN",
    		"KW_GET_FILE",
    		"KW_GET_1ST",
    		"KW_GET_FLT",
    		"KW_GET_GRN",
    		"KW_GET_HD_E",
    		"KW_GET_IBNN",
    		"KW_GET_IBQN",
    		"KW_GET_I64",
    		"KW_GET_ITER",
    		"KW_GET_LAST",
    		"KW_GET_LNBI",
    		"KW_GET_LIC",
    		"KW_GET_LONG",
    		"KW_GET_LPRM",
    		"KW_GET_L_V",
    		"KW_GET_MOP",
    		"KW_GET_MSG",
    		"KW_GET_MSGG",
    		"KW_GET_MSGS",
    		"KW_GET_NEXT",
    		"KW_GET_NODE",
    		"KW_GET_NUM",
    		"KW_GET_PAR",
    		"KW_GET_PTR",
    		"KW_GET_PREV",
    		"KW_GET_PROP",
    		"KW_GET_PRT",
    		"KW_GET_QNBI",
    		"KW_GET_R_R",
    		"KW_GET_RED",
    		"KW_GET_REL",
    		"KW_GET_RGB",
    		"KW_GET_SHRT",
    		"KW_GET_SELW",
    		"KW_GET_SER",
    		"KW_GET_SIG",
    		"KW_GET_SRCB",
    		"KW_GET_SZ",
    		"KW_GET_S_O",
    		"KW_GET_STR",
    		"KW_GET_T_S",
    		"KW_GET_TBI",
    		"KW_GET_TBNN",
    		"KW_GET_TBQN",
    		"KW_GET_TI",
    		"KW_GET_THCH",
    		"KW_GET_THPX",
    		"KW_GET_TOPB",
    		"KW_GET_TWCH",
    		"KW_GET_TWPX",
    		"KW_GET_UBI",
    		"KW_GET_UL",
    		"KW_GET_USHT",
    		"KW_GET_U_F",
    		"KW_GET_VAL",
    		"KW_GET_VBI",
    		"KW_GET_VBNN",
    		"KW_GET_VBQN",
    		"KW_GET_WAIT",
    		"KW_GET_WKDR",
    		"KW_GO",
    		"KW_GOTO",
    		"KW_GRD_F_H",
    		"KW_GRD_F_V",
    		"KW_GRD_SNAP",
    		"KW_GRD_UHC",
    		"KW_GRD_UHP",
    		"KW_GRD_UWC",
    		"KW_GRD_UWP",
    		"KW_GRD_VIS",
    		"KW_GROUP_BX",
    		"KW_GETCLASS",
    		"KW_GET_CGI",
    		"KW_GET_COOK",
    		"KW_GET_FLD",
    		"KW_GT",
    		"KW_GTE",
    		"KW_GUID",
    		"KW_HANDLE",
    		"KW_HANDLER",
    		"KW_HAS_LOBS",
    		"KW_HAS_REC",
    		"KW_HEIGHT_C",
    		"KW_HEIGHT_P",
    		"KW_HELP_TOP",
    		"KW_HEX_DECD",
    		"KW_HEX_ENCD",
    		"KW_HID_FLD",
    		"KW_HID_FLDL",
    		"KW_HIDDEN",
    		"KW_HINT",
    		"KW_HOME",
    		"KW_HORIZ",
    		"KW_HTML_CHS",
    		"KW_HTML_ENC",
    		"KW_HTML_EOL",
    		"KW_HTML_EOP",
    		"KW_HTML_FRB",
    		"KW_HTML_FRE",
    		"KW_HTML_H_B",
    		"KW_HTML_H_E",
    		"KW_HTML_T_B",
    		"KW_HTML_T_E",
    		"KW_HTMLERR",
    		"KW_HWND",
    		"KW_HYPERLNK",
    		"KW_HONOR_PK",
    		"KW_HONOR_RK",
    		"KW_ICON",
    		"KW_ICFPARM",
    		"KW_IDEPHWND",
    		"KW_IDEWNTYP",
    		"KW_IDX_HINT",
    		"KW_IDX_INFO",
    		"KW_IGN_CMOD",
    		"KW_IMAGE",
    		"KW_IMG_DOWN",
    		"KW_IMG_INS",
    		"KW_IMG_ONLY",
    		"KW_IMG_SZ",
    		"KW_IMG_SZ_C",
    		"KW_IMG_SZ_P",
    		"KW_IMG_UP",
    		"KW_IDX_REPO",
    		"KW_IMM_DISP",
    		"KW_IMP_NODE",
    		"KW_IMP_PRNC",
    		"KW_IMPLEMTS",
    		"KW_IN_HNDL",
    		"KW_INC_EX_I",
    		"KW_INFO",
    		"KW_INH_BGC",
    		"KW_INH_FGC",
    		"KW_INHERITS",
    		"KW_INIT_SES",
    		"KW_INIT",
    		"KW_INIT_C_P",
    		"KW_INIT_D_T",
    		"KW_INIT_DIR",
    		"KW_INIT_FLT",
    		"KW_INITIATE",
    		"KW_INNER_C",
    		"KW_INNER_L",
    		"KW_INNER",
    		"KW_INPT_VAL",
    		"KW_INS_ATTR",
    		"KW_INS_B4",
    		"KW_INS_BTAB",
    		"KW_INS_COL",
    		"KW_INS_FLD",
    		"KW_INS_FLDD",
    		"KW_INS_FLDL",
    		"KW_INS_MODE",
    		"KW_INS_FILE",
    		"KW_INS_ROW",
    		"KW_INS_STR",
    		"KW_INS_TAB",
    		"KW_INST_PRC",
    		"KW_INT",
    		"KW_INT64",
    		"KW_INT_ENT",
    		"KW_INTERFAC",
    		"KW_INTERVAL",
    		"KW_INVOKE",
    		"KW_IP_TIME",
    		"KW_IS_CLASS",
    		"KW_IS_COLCP",
    		"KW_IS_CP_FX",
    		"KW_IS_DB_MT",
    		"KW_IS_JSON",
    		"KW_IS_M_TEN",
    		"KW_IS_OPEN",
    		"KW_IS_PART",
    		"KW_IS_P_SET",
    		"KW_IS_R_SEL",
    		"KW_IS_SEL",
    		"KW_IS_XML",
    		"KW_ISO_DATE",
    		"KW_ITEM",
    		"KW_ITEM_ROW",
    		"KW_ITER_CHG",
    		"KW_IUNKNOWN",
    		"KW_JAVA",
    		"KW_JOIN_BY",
    		"KW_KEEP_CON",
    		"KW_KEEP_ZOR",
    		"KW_KEEP_MSG",
    		"KW_KEEP_SEC",
    		"KW_KEEP_TAB",
    		"KW_KEY",
    		"KW_KW_ALL",
    		"KW_LAB_BGC",
    		"KW_LAB_DC",
    		"KW_LAB_FGC",
    		"KW_LAB_FONT",
    		"KW_LAB_PFC",
    		"KW_LABELS",
    		"KW_LAB_H_C",
    		"KW_LANDSCAP",
    		"KW_LANGUAGE",
    		"KW_LARGE",
    		"KW_LAST_BAT",
    		"KW_LAST_FRM",
    		"KW_LAST_OBJ",
    		"KW_LAST_TI",
    		"KW_LG_2_SM",
    		"KW_LAST_AR",
    		"KW_LAST_CH",
    		"KW_LAST_PRC",
    		"KW_LAST_SRV",
    		"KW_LAST_SS",
    		"KW_LAST_SOC",
    		"KW_LCHR_2NV",
    		"KW_LEFT",
    		"KW_LEFT_AL",
    		"KW_LEFT_END",
    		"KW_LEFT_MC",
    		"KW_LEFT_MDC",
    		"KW_LEFT_MD",
    		"KW_LEFT_MU",
    		"KW_LENGTH",
    		"KW_LINE",
    		"KW_L_TRIM",
    		"KW_LIB_C_C",
    		"KW_LISTINGS",
    		"KW_LST_PAIR",
    		"KW_LIST_ITM",
    		"KW_LIST_PNM",
    		"KW_LIT_QSTN",
    		"KW_LST_EVNT",
    		"KW_LST_QRY",
    		"KW_LST_SET",
    		"KW_LST_WID",
    		"KW_LOAD",
    		"KW_LOAD_DMN",
    		"KW_LOAD_ICO",
    		"KW_LOAD_IMG",
    		"KW_LOAD_I_D",
    		"KW_LOAD_I_I",
    		"KW_LOAD_I_U",
    		"KW_LOAD_M_P",
    		"KW_LOAD_PIC",
    		"KW_LOAD_S_I",
    		"KW_LOADCTRL",
    		"KW_LOB_DIR",
    		"KW_LOC_V_I",
    		"KW_LOC_C_N",
    		"KW_LOC_HOST",
    		"KW_LOC_L_N",
    		"KW_LOC_NAME",
    		"KW_LOC_PORT",
    		"KW_LOC_P_ID",
    		"KW_LOC_S_ID",
    		"KW_LOC_TYPE",
    		"KW_LOCK_REG",
    		"KW_LOG",
    		"KW_LOG_A_EV",
    		"KW_LOG_E_TS",
    		"KW_LOG_EN_T",
    		"KW_LOG_ID",
    		"KW_LOG_HOST",
    		"KW_LOG_STAT",
    		"KW_LOG_THRS",
    		"KW_LOGF_NAM",
    		"KW_LOGG_LEV",
    		"KW_LOGICAL",
    		"KW_LOGOUT",
    		"KW_LOOKAHD",
    		"KW_LONG",
    		"KW_LONGCHAR",
    		"KW_LC",
    		"KW_LT",
    		"KW_LTE",
    		"KW_MAINMENU",
    		"KW_MAND",
    		"KW_MAN_HIGH",
    		"KW_MARG_EX",
    		"KW_MARG_H_C",
    		"KW_MARG_H_P",
    		"KW_MARG_W_C",
    		"KW_MARG_W_P",
    		"KW_MARK_NEW",
    		"KW_MARK_RS",
    		"KW_MATCHES",
    		"KW_MAX",
    		"KW_MAX_BTN",
    		"KW_MAX_CHAR",
    		"KW_MAX_D_G",
    		"KW_MAX_HT",
    		"KW_MAX_H_C",
    		"KW_MAX_H_P",
    		"KW_MAX_LVL",
    		"KW_MAX_W_C",
    		"KW_MAX_W_P",
    		"KW_MAX_ROWS",
    		"KW_MAX_SZ",
    		"KW_MAX_VAL",
    		"KW_MAX_WID",
    		"KW_MAXIMIZE",
    		"KW_MD5_VAL",
    		"KW_MD5_DIG",
    		"KW_MEMPTR",
    		"KW_MPTR_2NV",
    		"KW_MENU",
    		"KW_MENU_BAR",
    		"KW_MENU_DRP",
    		"KW_MENU_ITM",
    		"KW_MENU_KEY",
    		"KW_MENU_MOU",
    		"KW_MERGE_BF",
    		"KW_MERGE_CH",
    		"KW_MERGE_RC",
    		"KW_METHOD",
    		"KW_MF_DFR",
    		"KW_MF_DI",
    		"KW_MF_DIP",
    		"KW_MF_DL",
    		"KW_MF_DR",
    		"KW_MF_DT",
    		"KW_MF_DTAX",
    		"KW_MF_DTAXL",
    		"KW_MF_DTAXR",
    		"KW_MF_DTB",
    		"KW_MF_DTBL",
    		"KW_MF_DTBR",
    		"KW_MF_DTSX",
    		"KW_MF_GF",
    		"KW_MF_GFH",
    		"KW_MF_GFSD",
    		"KW_MF_GFSR",
    		"KW_MF_GPH",
    		"KW_MF_GPN",
    		"KW_MF_GPW",
    		"KW_MF_GTW",
    		"KW_MF_GXY",
    		"KW_MF_GZF",
    		"KW_MF_INIT",
    		"KW_MF_IR",
    		"KW_MF_MPDF",
    		"KW_MF_P2MU",
    		"KW_MF_RP",
    		"KW_MF_SF",
    		"KW_MF_SFC",
    		"KW_MF_SFH",
    		"KW_MF_SI",
    		"KW_MF_SIA",
    		"KW_MF_SLA",
    		"KW_MF_SLC",
    		"KW_MF_SLM",
    		"KW_MF_SLS",
    		"KW_MF_SNP",
    		"KW_MF_SNTL",
    		"KW_MF_SPF",
    		"KW_MF_SPN",
    		"KW_MF_SPNP",
    		"KW_MF_SPNT",
    		"KW_MF_SPO",
    		"KW_MF_SR",
    		"KW_MF_STA",
    		"KW_MF_STC",
    		"KW_MF_STS",
    		"KW_MF_SXY",
    		"KW_MF_SZF",
    		"KW_MODIFIRS",
    		"KW_MSG_AREA",
    		"KW_MSG_AFNT",
    		"KW_MSG_AMSG",
    		"KW_MSG_DIG",
    		"KW_MESSAGES",
    		"KW_MDL_MC",
    		"KW_MDL_MDC",
    		"KW_MDL_MD",
    		"KW_MDL_MU",
    		"KW_MIN",
    		"KW_MIN_BTN",
    		"KW_MIN_CWCH",
    		"KW_MIN_CWPX",
    		"KW_MIN_H_C",
    		"KW_MIN_H_P",
    		"KW_MIN_SCHM",
    		"KW_MIN_SZ",
    		"KW_MIN_VAL",
    		"KW_MIN_W_C",
    		"KW_MIN_W_P",
    		"KW_MNEMON",
    		"KW_MODIFIED",
    		"KW_MOD",
    		"KW_MONTH",
    		"KW_MOU_XC",
    		"KW_MOU_XDC",
    		"KW_MOU_XD",
    		"KW_MOU_XU",
    		"KW_MOU_MC",
    		"KW_MOU_MDC",
    		"KW_MOU_MD",
    		"KW_MOU_MU",
    		"KW_MOU_MVC",
    		"KW_MOU_MVDC",
    		"KW_MOU_MVD",
    		"KW_MOU_MVU",
    		"KW_MOU_PTR",
    		"KW_MOU_SC",
    		"KW_MOU_SDC",
    		"KW_MOU_SD",
    		"KW_MOU_SU",
    		"KW_MOVABLE",
    		"KW_MOVE",
    		"KW_MOV_A_T",
    		"KW_MOV_B_T",
    		"KW_MOV_COL",
    		"KW_MOV_2_B",
    		"KW_MOV_2_T",
    		"KW_MOV_2EOF",
    		"KW_MSICON",
    		"KW_MSPNTNUM",
    		"KW_MTIME",
    		"KW_MULT_CMP",
    		"KW_MULTIPLE",
    		"KW_MULT_KEY",
    		"KW_MULTI_IN",
    		"KW_MUST_EXI",
    		"KW_MUST_UND",
    		"KW_NAME",
    		"KW_NAMESP_P",
    		"KW_NAMESP_U",
    		"KW_NATIVE",
    		"KW_NE",
    		"KW_NEEDS_AP",
    		"KW_NEEDS_PR",
    		"KW_NESTED",
    		"KW_NEXT_COL",
    		"KW_NEXT_ERR",
    		"KW_NEXT_FR",
    		"KW_NEXT_RID",
    		"KW_NEXT_SIB",
    		"KW_NEXT_TAB",
    		"KW_NEXT_VAL",
    		"KW_NEXTWORD",
    		"KW_NEW_INST",
    		"KW_NEW_LINE",
    		"KW_NEW_ROW",
    		"KW_NEW_SESS",
    		"KW_NON_SER",
    		"KW_NNMSP_SL",
    		"KW_NORMAL",
    		"KW_NORMALZE",
    		"KW_NO_APPLY",
    		"KW_NO_ARMSG",
    		"KW_NO_ASSGN",
    		"KW_NO_AUTOV",
    		"KW_NO_BIND",
    		"KW_NO_BOX",
    		"KW_NO_COLS",
    		"KW_NO_CONS",
    		"KW_NO_CVT",
    		"KW_NO_CV_3D",
    		"KW_NO_CUR_V",
    		"KW_NO_DEBUG",
    		"KW_NO_DRAG",
    		"KW_NO_ECHO",
    		"KW_NO_EH_SR",
    		"KW_NO_EH_FL",
    		"KW_NO_EM_SP",
    		"KW_NO_HELP",
    		"KW_NO_IDX_H",
    		"KW_NO_INHBG",
    		"KW_NO_INHFG",
    		"KW_NO_JOIN",
    		"KW_NO_LOOKA",
    		"KW_NO_ROW_M",
    		"KW_NO_SCH_M",
    		"KW_NO_SEP_C",
    		"KW_NO_SEPS",
    		"KW_NO_SCR_V",
    		"KW_NO_TAB_S",
    		"KW_NO_UNDL",
    		"KW_NO_WRAP",
    		"KW_NODE_CHE",
    		"KW_NODE_VAL",
    		"KW_NODE_V2M",
    		"KW_NODV_2LC",
    		"KW_NONE",
    		"KW_NUM_BUFF",
    		"KW_NUM_BUTT",
    		"KW_NUM_CHLN",
    		"KW_NUM_CH_R",
    		"KW_NUM_COL",
    		"KW_NUM_COPY",
    		"KW_NUM_DROP",
    		"KW_NUM_FLD",
    		"KW_NUM_FMTS",
    		"KW_NUM_HD_E",
    		"KW_NUM_ITMS",
    		"KW_NUM_ITER",
    		"KW_NUM_LOGF",
    		"KW_NUM_LK_C",
    		"KW_NUM_LNS",
    		"KW_NUM_MSG",
    		"KW_NUM_PARM",
    		"KW_NUM_REF",
    		"KW_NUM_REL",
    		"KW_NUM_REPL",
    		"KW_NUM_RES",
    		"KW_NUM_SR",
    		"KW_NUM_SRCB",
    		"KW_NUM_TOPB",
    		"KW_NUM_SW",
    		"KW_NUM_TABS",
    		"KW_NUM_2RTN",
    		"KW_NUM_V_C",
    		"KW_NUM_D_P",
    		"KW_NUMERIC",
    		"KW_NUM_FMT",
    		"KW_NUM_SEP",
    		"KW_OBJECT",
    		"KW_OCT_LEN",
    		"KW_OFF_END",
    		"KW_OFF_HOME",
    		"KW_OK",
    		"KW_OK_CAN",
    		"KW_OLE_INVL",
    		"KW_OLE_NAML",
    		"KW_ON_FR_B",
    		"KW_ONLY",
    		"KW_ORG_HAND",
    		"KW_ORG_ROID",
    		"KW_ORDER",
    		"KW_ORD_JOIN",
    		"KW_OPEN_L_A",
    		"KW_OPENMIME",
    		"KW_OPENPOPU",
    		"KW_OPEN_URL",
    		"KW_OPTIONS",
    		"KW_OPTIONSF",
    		"KW_ORDINAL",
    		"KW_OS_DRV",
    		"KW_OS_ERR",
    		"KW_OS_G_ENV",
    		"KW_OS_UID",
    		"KW_OUT_JOIN",
    		"KW_OUTER",
    		"KW_OUTPUTCT",
    		"KW_OUT_HDR",
    		"KW_OUT_HH",
    		"KW_OUT_MSGS",
    		"KW_OVERRIDE",
    		"KW_OWNER",
    		"KW_OWN_DOC",
    		"KW_P2J_RC",
    		"KW_PAGE_DWN",
    		"KW_PAGE_LFT",
    		"KW_PAGE_RT",
    		"KW_PAGE_SZ",
    		"KW_PAGE_UP",
    		"KW_PAGE_WID",
    		"KW_PAGED",
    		"KW_PAR_BUFF",
    		"KW_PAR_FLDA",
    		"KW_PAR_FLDB",
    		"KW_PAR_IFLD",
    		"KW_PAR_IREL",
    		"KW_PAR_REL",
    		"KW_PAR_W_C",
    		"KW_PARENT",
    		"KW_PART_KEY",
    		"KW_PATHNAME",
    		"KW_PARSE_ST",
    		"KW_PASCAL",
    		"KW_PASTE",
    		"KW_PBE_H_AL",
    		"KW_PBE_KEYR",
    		"KW_PERF",
    		"KW_PREF_DS",
    		"KW_PRE_LBL",
    		"KW_PRS_PROC",
    		"KW_PRS_C_D",
    		"KW_PFCOLOR",
    		"KW_PICK",
    		"KW_PICK_ARE",
    		"KW_PICK_BTH",
    		"KW_PIX_COL",
    		"KW_PIX_ROW",
    		"KW_PK_PRIV",
    		"KW_PK_PROT",
    		"KW_POLY",
    		"KW_POP_MENU",
    		"KW_POP_ONLY",
    		"KW_PORTRAIT",
    		"KW_POS",
    		"KW_PRECISN",
    		"KW_PREP_STR",
    		"KW_PREPARED",
    		"KW_PRESEL",
    		"KW_PREV",
    		"KW_PREV_COL",
    		"KW_PREV_FR",
    		"KW_PREV_SIB",
    		"KW_PREV_T_I",
    		"KW_PREVWORD",
    		"KW_PRIM_P_P",
    		"KW_PRIMARY",
    		"KW_PRINTER",
    		"KW_PRT_C_H",
    		"KW_PRT_HDC",
    		"KW_PRT_NAME",
    		"KW_PRT_PORT",
    		"KW_PRT_SET",
    		"KW_PRIVATE",
    		"KW_PRIV_DAT",
    		"KW_PROCNAME",
    		"KW_PROCTYPE",
    		"KW_PROC_COM",
    		"KW_PROC",
    		"KW_PROC_W_R",
    		"KW_PROC_TXT",
    		"KW_PROC_T_B",
    		"KW_PRODATAS",
    		"KW_PROFILNG",
    		"KW_PROG_SRC",
    		"KW_PRO_ARCH",
    		"KW_PROPERTY",
    		"KW_PROTECTD",
    		"KW_PROXY",
    		"KW_PROX_PWD",
    		"KW_PROX_UID",
    		"KW_PUBLIC",
    		"KW_PUB_ID",
    		"KW_PUB_EVTS",
    		"KW_PUT_BITS",
    		"KW_PUT_BYTS",
    		"KW_PUT_I64",
    		"KW_PUT_DBL",
    		"KW_PUT_FLT",
    		"KW_PUT_LONG",
    		"KW_PUT_SHT",
    		"KW_PUT_STR",
    		"KW_PUT_UL",
    		"KW_PUT_USHT",
    		"KW_QRY_OPEN",
    		"KW_QRY_PREP",
    		"KW_QUAL_UID",
    		"KW_QUEST",
    		"KW_QUE_MSG",
    		"KW_QUOTER",
    		"KW_RADIO_B",
    		"KW_RADIO_S",
    		"KW_RANDOM",
    		"KW_RAW",
    		"KW_RAW_TRAN",
    		"KW_READ",
    		"KW_REAL",
    		"KW_READ_FIL",
    		"KW_READ_JSN",
    		"KW_READ_ONL",
    		"KW_READ_RES",
    		"KW_READ_XML",
    		"KW_READ_XSC",
    		"KW_RECALL",
    		"KW_REC_LEN",
    		"KW_RECURSE",
    		"KW_REF_ONLY",
    		"KW_REFR_A_P",
    		"KW_REFRESH",
    		"KW_REFRABLE",
    		"KW_REG_DMN",
    		"KW_REGISTER",
    		"KW_REJ_CHGS",
    		"KW_REJ_RCHG",
    		"KW_REJECTED",
    		"KW_REL_FLDS",
    		"KW_RELS_ACT",
    		"KW_RELSESID",
    		"KW_REM_HOST",
    		"KW_REM_PORT",
    		"KW_REMOTE",
    		"KW_REM_ATTR",
    		"KW_REM_EVTP",
    		"KW_REM_CHLD",
    		"KW_REM_SUP",
    		"KW_REPLACE",
    		"KW_REPOS_M",
    		"KW_REP_CHLD",
    		"KW_REP_STXT",
    		"KW_REPORTS",
    		"KW_REQUEST",
    		"KW_REQ_INFO",
    		"KW_RSP_INFO",
    		"KW_RESET",
    		"KW_RESIZE",
    		"KW_RESIZABL",
    		"KW_REST_RID",
    		"KW_REST_ROW",
    		"KW_RESULT",
    		"KW_RESUME_D",
    		"KW_RET_SHAP",
    		"KW_RETRY_C",
    		"KW_RET_INS",
    		"KW_RET_VAL",
    		"KW_RET_VDT",
    		"KW_RET_VLT",
    		"KW_RET_2SD",
    		"KW_RETURNS",
    		"KW_REV_FROM",
    		"KW_RFRSH_UI",
    		"KW_RGB_VAL",
    		"KW_RIGHT",
    		"KW_RIGHT_AL",
    		"KW_RT_END",
    		"KW_RT_MC",
    		"KW_RT_MDC",
    		"KW_RT_MD",
    		"KW_RT_MU",
    		"KW_R_TRIM",
    		"KW_ROLE",
    		"KW_ROLES",
    		"KW_ROUND",
    		"KW_ROUNDED",
    		"KW_ROUTINEL",
    		"KW_ROW",
    		"KW_ROW_CRT",
    		"KW_ROW_DEL",
    		"KW_ROW_DISP",
    		"KW_ROW_ENTR",
    		"KW_ROW_H_C",
    		"KW_ROW_H_P",
    		"KW_ROW_LEAV",
    		"KW_ROW_OF",
    		"KW_ROW_MARK",
    		"KW_ROW_RESZ",
    		"KW_ROW_STAT",
    		"KW_ROW_UPD",
    		"KW_ROWID",
    		"KW_RUN_PROC",
    		"KW_RUN_W_O",
    		"KW_RULE",
    		"KW_RULE_ROW",
    		"KW_RULE_Y",
    		"KW_SAVE_AS",
    		"KW_SAVE_FIL",
    		"KW_SAX_ATTR",
    		"KW_SAX_PARF",
    		"KW_SAX_PARN",
    		"KW_SAX_PARS",
    		"KW_SAX_READ",
    		"KW_SAX_WRIT",
    		"KW_SAVE_RCH",
    		"KW_SAVE_WST",
    		"KW_SCH_CHG",
    		"KW_SCH_LOC",
    		"KW_SCH_MARS",
    		"KW_SCH_PATH",
    		"KW_SCROLLBL",
    		"KW_SCROLLBA",
    		"KW_SCR_DELT",
    		"KW_SCR_LEFT",
    		"KW_SCROLL_H",
    		"KW_SCR_MODE",
    		"KW_SCR_NOT",
    		"KW_SCR_OFFS",
    		"KW_SCR_RT",
    		"KW_SCR_2CR",
    		"KW_SCR_2ITM",
    		"KW_SCR_2SR",
    		"KW_SCR_COL",
    		"KW_SCR_HGHT",
    		"KW_SCR_SCAL",
    		"KW_SCR_WDTH",
    		"KW_SCRN_VAL",
    		"KW_SCROLL_V",
    		"KW_SCR_RPOS",
    		"KW_SCROLLIN",
    		"KW_SEAL",
    		"KW_SEAL_TST",
    		"KW_SECTION",
    		"KW_SEL_ALL",
    		"KW_SEL_END",
    		"KW_SEL_FOCR",
    		"KW_SEL_NEXT",
    		"KW_SEL_PREV",
    		"KW_SEL_ROW",
    		"KW_SEL_STRT",
    		"KW_SEL_TXT",
    		"KW_SELECTBL",
    		"KW_SELECTED",
    		"KW_SELECTN",
    		"KW_SEL_LST",
    		"KW_SEND",
    		"KW_SEND_SQL",
    		"KW_SENSITIV",
    		"KW_SEPS",
    		"KW_SEP_CONN",
    		"KW_SEP_FGC",
    		"KW_SERIALAB",
    		"KW_SERIALZH",
    		"KW_SERIALZN",
    		"KW_SERIALZR",
    		"KW_SERVER",
    		"KW_SESS_END",
    		"KW_SESSN_ID",
    		"KW_SRV_C_B",
    		"KW_SRV_C_BR",
    		"KW_SRV_C_C",
    		"KW_SRV_C_I",
    		"KW_SRV_OP_M",
    		"KW_SETTINGS",
    		"KW_SET_ACTR",
    		"KW_SET_ACTX",
    		"KW_SET_ATTR",
    		"KW_SET_A_L",
    		"KW_SET_A_N",
    		"KW_SET_BLUE",
    		"KW_SET_BRK",
    		"KW_SET_BUF",
    		"KW_SET_B_OR",
    		"KW_SET_CB_P",
    		"KW_SET_CBAC",
    		"KW_SET_CLNT",
    		"KW_SET_COMM",
    		"KW_SET_C_P",
    		"KW_SET_CONT",
    		"KW_SET_COOK",
    		"KW_SET_DBCL",
    		"KW_SET_DYN",
    		"KW_SET_EVMO",
    		"KW_SET_GRN",
    		"KW_SET_ISRC",
    		"KW_SET_LSTK",
    		"KW_SET_M_UN",
    		"KW_SET_N_F",
    		"KW_SET_NODE",
    		"KW_SET_ODST",
    		"KW_SET_OPT",
    		"KW_SET_PARM",
    		"KW_SET_PROP",
    		"KW_SET_PTR",
    		"KW_SET_RED",
    		"KW_SET_RGB",
    		"KW_SET_RRP",
    		"KW_SET_RPOS",
    		"KW_SET_ROLL",
    		"KW_SET_SEL",
    		"KW_SET_SERD",
    		"KW_SET_SZ",
    		"KW_SET_S_AR",
    		"KW_SET_T_S",
    		"KW_SET_U_F",
    		"KW_SET_S_O",
    		"KW_SET_WAIT",
    		"KW_SET_WKDR",
    		"KW_SET_W_S",
    		"KW_SRV_SOCK",
    		"KW_SHA1_DIG",
    		"KW_SHORT",
    		"KW_SHOW_ITB",
    		"KW_SIDE_L",
    		"KW_SIDE_L_H",
    		"KW_SIGNATUR",
    		"KW_SILENT",
    		"KW_SIMPLE",
    		"KW_SINGLE",
    		"KW_SINGLTON",
    		"KW_SIZE",
    		"KW_SIZE_C",
    		"KW_SIZE_P",
    		"KW_SLIDER",
    		"KW_SMAL_ICO",
    		"KW_SMAL_TTL",
    		"KW_SMALLINT",
    		"KW_SRC_PROC",
    		"KW_SOAP_HDR",
    		"KW_SOAP_HER",
    		"KW_SOAP_F",
    		"KW_SOAP_F_A",
    		"KW_SOAP_F_C",
    		"KW_SOAP_F_D",
    		"KW_SOAP_FMH",
    		"KW_SOAP_F_N",
    		"KW_SOAP_F_R",
    		"KW_SOAP_F_S",
    		"KW_SOAP_FSC",
    		"KW_SOAP_VER",
    		"KW_SOCKET",
    		"KW_SORT",
    		"KW_SORT_ASC",
    		"KW_SORT_NUM",
    		"KW_SOURCE",
    		"KW_SQL",
    		"KW_SQRT",
    		"KW_SSL_SRVN",
    		"KW_STANDALN",
    		"KW_START",
    		"KW_START_BS",
    		"KW_START_DC",
    		"KW_START_EL",
    		"KW_START_MV",
    		"KW_START_RS",
    		"KW_START_RR",
    		"KW_START_SC",
    		"KW_STARTING",
    		"KW_STAT_DET",
    		"KW_STATIC",
    		"KW_STATUS_A",
    		"KW_STAT_A_F",
    		"KW_STDCALL",
    		"KW_STOP",
    		"KW_STOP_AFT",
    		"KW_STOP_D",
    		"KW_STOP_PRS",
    		"KW_STOPPED",
    		"KW_STORPROC",
    		"KW_STUP_PAR",
    		"KW_ST_2_FIT",
    		"KW_STR_VAL",
    		"KW_STR_XREF",
    		"KW_STRICT",
    		"KW_STRIC_ER",
    		"KW_STRING",
    		"KW_SUB_AVG",
    		"KW_SUB_CNT",
    		"KW_SUB_MAX",
    		"KW_SUB_MENU",
    		"KW_SUB_M_H",
    		"KW_SUB_MIN",
    		"KW_SUB_TOT",
    		"KW_SUBSTIT",
    		"KW_SUBSTR",
    		"KW_SUBTYPE",
    		"KW_SUM",
    		"KW_SUP_NS_P",
    		"KW_SUP_PROC",
    		"KW_SUP_WARN",
    		"KW_SUPW_LST",
    		"KW_SYM_EN_A",
    		"KW_SYM_EN_I",
    		"KW_SYM_EN_K",
    		"KW_SYM_SUPP",
    		"KW_SYNCHRON",
    		"KW_SYS_A_B",
    		"KW_SYS_HELP",
    		"KW_SYS_ID",
    		"KW_TAB",
    		"KW_TAB_CRCL",
    		"KW_TAB_HAND",
    		"KW_TAB_LIST",
    		"KW_TAB_POS",
    		"KW_TAB_SCAN",
    		"KW_TAB_STOP",
    		"KW_TAG",
    		"KW_TARGET",
    		"KW_TAR_PROC",
    		"KW_TEMP_DIR",
    		"KW_TEMP_TAB",
    		"KW_TRC_FILT",
    		"KW_TRAC_CHG",
    		"KW_TT_PREP",
    		"KW_TEN_ID",
    		"KW_TENNAME",
    		"KW_TN_TOID",
    		"KW_TERM_HK",
    		"KW_TERMINAT",
    		"KW_TXT_SEG",
    		"KW_TXT_SEL",
    		"KW_3D",
    		"KW_THROUGH",
    		"KW_THROW",
    		"KW_THR_SAFE",
    		"KW_TIC_MARK",
    		"KW_TIMEZONE",
    		"KW_TIME_SRC",
    		"KW_TITL_BGC",
    		"KW_TITL_DC",
    		"KW_TITL_FGC",
    		"KW_TITL_FON",
    		"KW_TODAY",
    		"KW_TOGGL_BX",
    		"KW_TOOLTIP",
    		"KW_TOOLTIPS",
    		"KW_TOP",
    		"KW_TOP_COL",
    		"KW_TOP_NAVQ",
    		"KW_TOPIC",
    		"KW_TOTAL",
    		"KW_TRACING",
    		"KW_TRAILING",
    		"KW_TRAN_I_P",
    		"KW_TRAN_MOD",
    		"KW_TRANSPAR",
    		"KW_TRUNC",
    		"KW_TTCP",
    		"KW_TYPE",
    		"KW_TYPE_OF",
    		"KW_UNBOX",
    		"KW_UNBUF",
    		"KW_UNDO_T_S",
    		"KW_UNIQ_ID",
    		"KW_UNIQ_MAT",
    		"KW_UNIX_END",
    		"KW_UNL_HID",
    		"KW_UNLOAD",
    		"KW_UNS_BYTE",
    		"KW_UNS_SHRT",
    		"KW_UNS_LONG",
    		"KW_UPD_ATTR",
    		"KW_URL",
    		"KW_URL_DECO",
    		"KW_URL_ENCO",
    		"KW_URL_FLD",
    		"KW_URL_FLDL",
    		"KW_URL_FMT",
    		"KW_URL_PW",
    		"KW_URL_UID",
    		"KW_USE",
    		"KW_USE_DCT",
    		"KW_USE_FIL",
    		"KW_USE_REV",
    		"KW_USE_TXT",
    		"KW_USE_UND",
    		"KW_USE_WIDP",
    		"KW_USR_DATA",
    		"KW_USER_ID",
    		"KW_UTC_OFF",
    		"KW_V6DISP",
    		"KW_VAL_ENAB",
    		"KW_VAL_EXPR",
    		"KW_VAL_MSG",
    		"KW_VAL_SEAL",
    		"KW_VAL_XML",
    		"KW_VALIDATE",
    		"KW_VAL_EVT",
    		"KW_VAL_HND",
    		"KW_VAL_OBJ",
    		"KW_VAR",
    		"KW_VERBOSE",
    		"KW_VERSION",
    		"KW_VERT",
    		"KW_VIEW_FCR",
    		"KW_VIRT_HC",
    		"KW_VIRT_HP",
    		"KW_VIRT_WC",
    		"KW_VIRT_WP",
    		"KW_VISIBLE",
    		"KW_WAIT",
    		"KW_VOID",
    		"KW_WARN",
    		"KW_WC_AD_AP",
    		"KW_WEB",
    		"KW_WEB_CTX",
    		"KW_WEB_FUP",
    		"KW_WEB_OUT",
    		"KW_WEEK",
    		"KW_WHERE_ST",
    		"KW_WIDGET",
    		"KW_WID_ENT",
    		"KW_WID_HAND",
    		"KW_WID_ID",
    		"KW_WID_LEAV",
    		"KW_WID_POOL",
    		"KW_WIDTH",
    		"KW_WIDTH_C",
    		"KW_WIDTH_P",
    		"KW_WIN_CLOS",
    		"KW_WIN_NAME",
    		"KW_WIN_RESI",
    		"KW_WIN_REST",
    		"KW_WIN_STAT",
    		"KW_WIN_SYS",
    		"KW_WORD_IDX",
    		"KW_WORD_WRP",
    		"KW_WA_H_P",
    		"KW_WA_W_P",
    		"KW_WA_X",
    		"KW_WA_Y",
    		"KW_WR_CDATA",
    		"KW_WR_CHARS",
    		"KW_WR_CMNT",
    		"KW_WR_DATA",
    		"KW_WR_D_ELM",
    		"KW_WR_E_ELM",
    		"KW_WR_ENT_R",
    		"KW_WR_EXDTD",
    		"KW_WR_FRAGM",
    		"KW_WR_JSON",
    		"KW_WR_MSG",
    		"KW_WR_PRINS",
    		"KW_WR_STAT",
    		"KW_WR_XML",
    		"KW_WR_XMLSC",
    		"KW_WUPL_ERR",
    		"KW_WUPL_FLS",
    		"KW_X",
    		"KW_XML_DTYP",
    		"KW_XML_E_EL",
    		"KW_XML_NNAM",
    		"KW_XML_NTYP",
    		"KW_XML_SCHP",
    		"KW_XML_S_ER",
    		"KW_XML_SNSP",
    		"KW_XPR2PDF",
    		"KW_X_DOC",
    		"KW_X_NODE",
    		"KW_X_OF",
    		"KW_YEAR",
    		"KW_YEAR_OFF",
    		"KW_YES_NO",
    		"KW_YES_NO_C",
    		"KW_Y",
    		"KW_Y_OF",
    		"BEGIN_FWD_EXTENSION",
    		"KW_TIMER",
    		"KW_CALLBACK",
    		"KW_ENABLED",
    		"KW_CEASE",
    		"CREATE_TIMER",
    		"CREATE_GENERIC_OCX",
    		"KW_CONNTYPE",
    		"KW_ACTIVATE",
    		"KW_ADD_TO_A",
    		"KW_ADD_CC_A",
    		"KW_ADD_BCCA",
    		"KW_AS_THRD",
    		"KW_ATT_FILE",
    		"KW_ATT_URL",
    		"KW_CHECK_BO",
    		"KW_CLR_ATTL",
    		"KW_CLR_BCCL",
    		"KW_CLR_CC_L",
    		"KW_CLR_EMBL",
    		"KW_CLR_TO_L",
    		"KW_EMB_FILE",
    		"KW_EMB_URL",
    		"KW_GET_ATTL",
    		"KW_GET_BCCL",
    		"KW_GET_CC_L",
    		"KW_GET_EMBL",
    		"KW_GET_TO_L",
    		"KW_SMTP_EML",
    		"KW_SMTPFROM",
    		"KW_SMTPHOST",
    		"KW_SMTPHTML",
    		"KW_SMTPPORT",
    		"KW_SMTPREPL",
    		"KW_SMTPSUBJ",
    		"KW_SMTPTEXT",
    		"KW_SMTPUSER",
    		"KW_SMTP_PW",
    		"KW_SMTP_VAL",
    		"CREATE_SMTP_EMAIL",
    		"KW_REPORT",
    		"KW_RPT_ADDC",
    		"KW_RPT_DSGN",
    		"KW_RPT_CAP",
    		"KW_RPT_CSV",
    		"KW_RPT_DOCX",
    		"KW_RPT_GSRC",
    		"KW_RPT_GSRR",
    		"KW_RPT_HTML",
    		"KW_RPT_ICSV",
    		"KW_RPT_PDF",
    		"KW_RPT_RTF",
    		"KW_RPT_SRC",
    		"KW_RPT_XLS",
    		"KW_RPT_XLSX",
    		"KW_SET_R_P",
    		"CREATE_REPORT",
    		"KW_TREEVIEW",
    		"KW_ADD_C_N",
    		"KW_ADD_F_N",
    		"KW_ADD_L_N",
    		"KW_ADD_N_N",
    		"KW_BUILD_TR",
    		"KW_CLR_ALL",
    		"KW_CLR_NIML",
    		"KW_CLR_NODS",
    		"KW_COL_NODE",
    		"KW_COLL_A_E",
    		"KW_COLL_ALL",
    		"KW_CRE_IMAG",
    		"KW_CREAT_SN",
    		"KW_CRT_MIMG",
    		"KW_DCLK_EXP",
    		"KW_DD_OTREE",
    		"KW_DRAGDROP",
    		"KW_ENS_N_V",
    		"KW_EXP_N_IC",
    		"KW_EXP_NODE",
    		"KW_EXP_ON_E",
    		"KW_EXP_SCLK",
    		"KW_EXPA_ALL",
    		"KW_FIND_NOD",
    		"KW_FIRST_N",
    		"KW_FNT_BOLD",
    		"KW_FNT_ITAL",
    		"KW_FNT_NAME",
    		"KW_FNT_SIZE",
    		"KW_FNT_UNDL",
    		"KW_FOC_NKEY",
    		"KW_FOC_NODE",
    		"KW_FS_NKEY",
    		"KW_FS_NODE",
    		"KW_FV_NODE",
    		"KW_GET_FCN",
    		"KW_GET_N_AT",
    		"KW_GET_N_BG",
    		"KW_GET_N_FG",
    		"KW_GET_N_HC",
    		"KW_GET_N_N",
    		"KW_GET_NLEV",
    		"KW_GET_NSN",
    		"KW_GET_NTXT",
    		"KW_GET_NVV",
    		"KW_GET_PARN",
    		"KW_GET_PSN",
    		"KW_GET_SNC",
    		"KW_GET_TNOD",
    		"KW_HIT_TEST",
    		"KW_HIT_TFWD",
    		"KW_INDENT",
    		"KW_IS_MSEL",
    		"KW_IS_N_EXP",
    		"KW_NEW_LBL",
    		"KW_N_AEDIT",
    		"KW_N_BEDIT",
    		"KW_N_CLICK",
    		"KW_N_COLED",
    		"KW_N_COLING",
    		"KW_N_EXPED",
    		"KW_N_EXPING",
    		"KW_N_HEIGHT",
    		"KW_N_KEY_ID",
    		"KW_NODE_BLD",
    		"KW_NODE_CNT",
    		"KW_NODE_EXP",
    		"KW_NODE_ICO",
    		"KW_NODE_ID",
    		"KW_NODE_IDX",
    		"KW_NODE_KEY",
    		"KW_NODE_PAR",
    		"KW_NODE_TXT",
    		"KW_NODES",
    		"KW_REM_NOCO",
    		"KW_REM_NODE",
    		"KW_SCR_NTOP",
    		"KW_SCR_VERT",
    		"KW_SCR_WLNS",
    		"KW_SEL_NID",
    		"KW_SEL_NKEY",
    		"KW_SEL_NODE",
    		"KW_SEL_SFVN",
    		"KW_SET_MSEL",
    		"KW_SET_N_BG",
    		"KW_SET_N_FG",
    		"KW_SET_N_HC",
    		"KW_SET_NTXT",
    		"KW_SET_SNC",
    		"KW_SET_TN_I",
    		"KW_SHOW_BUT",
    		"KW_TEXTEDIT",
    		"KW_TNOD_VAL",
    		"KW_TREE_R_H",
    		"KW_TRIG_NOD",
    		"KW_TRIG_COL",
    		"KW_SCR_NODC",
    		"KW_V_N_CNT",
    		"KW_V_R_CNT",
    		"KW_TABSET",
    		"KW_ADD_TAB",
    		"KW_TABS",
    		"KW_CLR_TABS",
    		"KW_CURR_TAB",
    		"KW_TAB_IDX",
    		"KW_TAB_ML",
    		"KW_TAB_SHOW",
    		"KW_SET_F_D",
    		"KW_FOC_ASEL",
    		"KW_HTML_BWS",
    		"KW_CTX_PATH",
    		"KW_OPENHTML",
    		"KW_OPENPAGE",
    		"KW_POSTMSG",
    		"KW_PRINT",
    		"KW_RES_BASE",
    		"KW_TREELIST",
    		"KW_AST_ACTI",
    		"KW_CRT_COL",
    		"KW_COL_SRT",
    		"KW_C_T_V_N",
    		"KW_C_NOD_D",
    		"KW_DATE_SEP",
    		"KW_DEC_SEP",
    		"KW_EVT_ACTI",
    		"KW_FIX_C_L",
    		"KW_G_C_BGCO",
    		"KW_G_C_FGCO",
    		"KW_G_COL_P",
    		"KW_G_COL_W",
    		"KW_GET_C_S",
    		"KW_IS_C_VIS",
    		"KW_M_D_I_P",
    		"KW_M_U_I_P",
    		"KW_RESORT",
    		"KW_S_C_BGCO",
    		"KW_S_C_FGCO",
    		"KW_S_COL_C",
    		"KW_S_COL_W",
    		"KW_SET_C_IC",
    		"KW_SET_C_S",
    		"KW_SET_C_VI",
    		"KW_SHOW_HDR",
    		"KW_SHR_D_F",
    		"KW_SOR_C_C",
    		"KW_SOR_COLS",
    		"KW_THO_SEP",
    		"KW_AT_W_BRW",
    		"KW_UPLOAD",
    		"KW_H_SCRL_P",
    		"KW_V_SCRL_P",
    		"KW_IMG_LIST",
    		"KW_IL_IMG",
    		"KW_IL_BGCOL",
    		"KW_IL_HEIGH",
    		"KW_IL_WIDTH",
    		"KW_IL_LIST",
    		"KW_IL_MASK",
    		"KW_IL_OVER",
    		"KW_IL_UMASK",
    		"KW_ADD_IMG",
    		"KW_MS_CLICK",
    		"KW_MS_DBCLK",
    		"KW_MS_DOWN",
    		"KW_MS_MOVE",
    		"KW_MS_UP",
    		"KW_OCX_MBTN",
    		"KW_OCX_MSHT",
    		"KW_OCX_MSX",
    		"KW_OCX_MSY",
    		"KW_OLE_DGMD",
    		"KW_OLE_DRMD",
    		"KW_OLE_DRAG",
    		"KW_OLE_EFFE",
    		"KW_OLE_STAT",
    		"KW_OLE_DEFC",
    		"KW_OLE_DATF",
    		"KW_OLE_AEFF",
    		"KW_OLE_CDRG",
    		"KW_OLE_DD",
    		"KW_OLE_DGOV",
    		"KW_OLE_GIVF",
    		"KW_OLE_SETD",
    		"KW_OLE_STDG",
    		"KW_OLE_X",
    		"KW_OLE_Y",
    		"KW_DRAG_NOD",
    		"KW_DRAG_OVR",
    		"KW_PROG_BAR",
    		"KW_PB_APPEA",
    		"KW_PB_ENABL",
    		"KW_PB_BRSTY",
    		"KW_PB_ORIEN",
    		"KW_PB_MIN",
    		"KW_PB_MAX",
    		"KW_PB_VALUE",
    		"KW_PB_SCROL",
    		"KW_COM_DATA",
    		"KW_CALBGCLR",
    		"KW_CALFGCLR",
    		"KW_CALTITBG",
    		"KW_CALTITFG",
    		"KW_CALTRLFG",
    		"KW_CALENDAR",
    		"KW_CALCUFMT",
    		"KW_CALFMTST",
    		"KW_CALUPDWN",
    		"KW_CALVALUE",
    		"KW_CLEA_TAB",
    		"KW_CLEA_WIN",
    		"KW_GET_SIMG",
    		"KW_KPAD_HOT",
    		"KW_KPAD_CLE",
    		"KW_KPAD_QRY",
    		"KW_LCD_REFR",
    		"KW_LCD_SWIN",
    		"KW_LCD_WSTR",
    		"KW_NUM_PNTS",
    		"KW_SET_IMGF",
    		"KW_SET_PENW",
    		"KW_SET_IMGH",
    		"KW_SET_IMGW",
    		"KW_SET_JMOD",
    		"KW_SET_JSTX",
    		"KW_SET_JSTY",
    		"KW_SET_CPTM",
    		"KW_SET_SWIN",
    		"KW_SET_TSTA",
    		"KW_SET_TBME",
    		"KW_TAB_MOD",
    		"KW_BTN_LIST",
    		"KW_BL_CURGR",
    		"KW_BL_CGR_K",
    		"KW_BL_BTNFN",
    		"KW_BL_ITMFN",
    		"KW_BL_GCLR",
    		"KW_BL_GADD",
    		"KW_BL_GIFP",
    		"KW_BL_IADD",
    		"KW_BL_G_KEY",
    		"KW_BL_GIKEY",
    		"KW_BL_NGR",
    		"KW_BL_NGRI",
    		"KW_BL_G_GR",
    		"KW_BL_G_GRI",
    		"KW_CAPFNT",
    		"KW_CAPFNTSZ",
    		"KW_SPRSHEET",
    		"KW_FLTR_MAP",
    		"KW_SORT_MAP",
    		"KW_DIS_STRP",
    		"KW_DIS_CEDT",
    		"KW_UNIQ_KEY",
    		"END_FWD_EXTENSION",
    		"END_UNRESERVED",
    		"BEGIN_CALLGRAPH",
    		"FILE_RESOURCE",
    		"AST_NODE",
    		"IPC_RESOURCE",
    		"NATIVE_PROGRAM_RESOURCE",
    		"UNKNOWN_RESOURCE",
    		"INCLUDES",
    		"RUN_FILENAME",
    		"RUN_FILENAME_ON_SERVER",
    		"RUN_INT_PROC",
    		"RUN_INT_PROC_ON_SERVER",
    		"RUN_VALUE",
    		"RUN_VALUE_ON_SERVER",
    		"RUN_PORT_TYPE_ON_SERVER",
    		"RUN_PORT_TYPE_VALUE_ON_SERVER",
    		"RUN_LIBRARY_REF",
    		"RUN_LIBRARY_REF_ON_SERVER",
    		"FUNCTION_CALL",
    		"AMBIGUOUS",
    		"MISSING",
    		"PROCEDURE_FILE",
    		"INCLUDE_FILE",
    		"SCHEMA_FILE",
    		"EXTERNAL_PROCEDURE",
    		"INTERNAL_PROCEDURE",
    		"LIBRARY_PROCEDURE",
    		"PORT_TYPE",
    		"SHARED_LIBRARY",
    		"NATIVE_API",
    		"NATIVE_PROCESS",
    		"CHILD_PROCESS",
    		"NETWORK_CONNECTION",
    		"COM_OBJECT",
    		"DDE_SERVER",
    		"OCX_CONTROL",
    		"DEFINE_PROPERTY_GET",
    		"DEFINE_PROPERTY_SET",
    		"MORE",
    		"END_CALLGRAPH",
    		"UNKNOWN_TOKEN",
    		"AT",
    		"EQUALS",
    		"LBRACKET",
    		"RBRACKET",
    		"COLON",
    		"COMMA",
    		"LPARENS",
    		"RPARENS",
    		"STRING",
    		"MULTIPLY",
    		"KW_NOT_ACTV",
    		"CARET",
    		"MULT_ASSIGN",
    		"PLUS_ASSIGN",
    		"MINUS_ASSIGN",
    		"DIV_ASSIGN",
    		"GT",
    		"LT",
    		"DIVIDE",
    		"UNKNOWN_VAL",
    		"NUM_LITERAL",
    		"SYMBOL",
    		"KW_LIKE_SEQ",
    		"NOT_EQ",
    		"GTE",
    		"LTE",
    		"DB_REF_NON_STATIC",
    		"WS",
    		"TILDE",
    		"COMMENT",
    		"HEX_DIGIT",
    		"VALID_SYM_CHAR",
    		"SSTRING",
    		"DSTRING",
    		"XSTRING",
    		"RSTRING",
    		"STR_OPTIONS",
    		"LETTER",
    		"DIGIT",
    		"SYM_CHAR",
    		"CMT_OPEN",
    		"CMT_CLOSE",
    		"SLASH_SLASH",
    		"MONTH_TRASH_MODE",
    		"YEAR_TRASH_MODE",
    		"JUNK"
    	};

    	protected void buildTokenTypeASTClassMap() {
    		tokenTypeToASTClassMap=null;
    	};

    	private static final long[] mk_tokenSet_0() {
    		long[] data = new long[48];
    		data[1]=6144L;
    		data[11]=2L;
    		data[13]=2305843009213693952L;
    		return data;
    	}
    	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
    	private static final long[] mk_tokenSet_1() {
    		long[] data = new long[48];
    		data[0]=2L;
    		return data;
    	}
    	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
    	private static final long[] mk_tokenSet_2() {
    		long[] data = new long[48];
    		data[0]=16L;
    		data[8]=512L;
    		data[14]=4194304L;
    		return data;
    	}
    	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
    	private static final long[] mk_tokenSet_3() {
    		long[] data = new long[48];
    		data[0]=16L;
    		data[14]=4194304L;
    		return data;
    	}
    	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
    	private static final long[] mk_tokenSet_4() {
    		long[] data = new long[48];
    		data[18]=1152921504606847040L;
    		return data;
    	}
    	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
    	private static final long[] mk_tokenSet_5() {
    		long[] data = new long[48];
    		data[0]=16L;
    		return data;
    	}
    	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
    	private static final long[] mk_tokenSet_6() {
    		long[] data = new long[96];
    		data[0]=-14L;
    		for (int i = 1; i<=45; i++) { data[i]=-1L; }
    		data[46]=-17592186044417L;
    		data[47]=31L;
    		return data;
    	}
    	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
    	private static final long[] mk_tokenSet_7() {
    		long[] data = new long[94];
    		data[0]=3079336245214576656L;
    		data[1]=468607L;
    		data[8]=72339069014639104L;
    		data[9]=134217728L;
    		data[10]=576460752307617792L;
    		data[11]=262144L;
    		data[14]=2151677952L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[21]=2251799813685248L;
    		data[25]=4398046511104L;
    		data[26]=-9223372036854775808L;
    		data[27]=9007199254740992L;
    		data[28]=6144L;
    		data[29]=4294967296L;
    		data[31]=562949953421312L;
    		data[32]=140737488355328L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
    	private static final long[] mk_tokenSet_8() {
    		long[] data = new long[60];
    		data[0]=36028797018963984L;
    		data[1]=65L;
    		data[8]=512L;
    		data[14]=4194304L;
    		data[25]=4398046511104L;
    		data[28]=2048L;
    		data[29]=4294967296L;
    		return data;
    	}
    	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
    	private static final long[] mk_tokenSet_9() {
    		long[] data = new long[94];
    		data[0]=1261606029989249040L;
    		data[1]=475333L;
    		data[8]=512L;
    		data[11]=262144L;
    		data[14]=4194304L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[24]=1152921504606846976L;
    		data[25]=4398046511104L;
    		data[28]=2048L;
    		data[29]=4294967296L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
    	private static final long[] mk_tokenSet_10() {
    		long[] data = new long[94];
    		data[0]=-3386108785457102832L;
    		data[1]=475332L;
    		data[8]=512L;
    		data[11]=262144L;
    		data[14]=4259840L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[24]=1152921504606846976L;
    		data[32]=576460752303423488L;
    		data[40]=8192L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
    	private static final long[] mk_tokenSet_11() {
    		long[] data = new long[94];
    		data[0]=4268884681165897744L;
    		data[1]=485118L;
    		data[8]=72339069014639104L;
    		data[9]=134217728L;
    		data[10]=576460752307617792L;
    		data[11]=262144L;
    		data[14]=2151677952L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[21]=2251799813685248L;
    		data[24]=1152921504606846976L;
    		data[25]=4398046511104L;
    		data[26]=-9223372036854775808L;
    		data[27]=9007199254740992L;
    		data[28]=4096L;
    		data[31]=562949953421312L;
    		data[32]=140737488355328L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
    	private static final long[] mk_tokenSet_12() {
    		long[] data = new long[94];
    		data[0]=-342801337261490160L;
    		data[1]=485118L;
    		data[8]=72339069014639104L;
    		data[9]=134217728L;
    		data[10]=576460752307617792L;
    		data[11]=262144L;
    		data[14]=2151743488L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[21]=2251799813685248L;
    		data[24]=1152921504606846976L;
    		data[25]=4398046511104L;
    		data[26]=-9223372036854775808L;
    		data[27]=9007199254740992L;
    		data[28]=4096L;
    		data[31]=562949953421312L;
    		data[32]=576601489791778816L;
    		data[40]=8192L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
    	private static final long[] mk_tokenSet_13() {
    		long[] data = new long[94];
    		data[0]=1225577232970285072L;
    		data[1]=475332L;
    		data[8]=512L;
    		data[11]=262144L;
    		data[14]=4194304L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[24]=1152921504606846976L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
    	private static final long[] mk_tokenSet_14() {
    		long[] data = new long[94];
    		data[0]=3043307448195612688L;
    		data[1]=468542L;
    		data[8]=72339069014639104L;
    		data[9]=134217728L;
    		data[10]=576460752307617792L;
    		data[11]=262144L;
    		data[14]=2151677952L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[21]=2251799813685248L;
    		data[25]=4398046511104L;
    		data[26]=-9223372036854775808L;
    		data[27]=9007199254740992L;
    		data[28]=4096L;
    		data[31]=562949953421312L;
    		data[32]=140737488355328L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
    	private static final long[] mk_tokenSet_15() {
    		long[] data = new long[94];
    		data[0]=3043307448195612688L;
    		data[1]=474686L;
    		data[3]=770048L;
    		data[8]=72339069014639104L;
    		data[9]=134217728L;
    		data[10]=576460752307617856L;
    		data[11]=1152921504607109122L;
    		data[13]=2305843009213693952L;
    		data[14]=2151677952L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[21]=2251799813685248L;
    		data[25]=4398046511104L;
    		data[26]=-9223372036854775808L;
    		data[27]=9007199254740992L;
    		data[28]=4096L;
    		data[31]=562949953421312L;
    		data[32]=140737488355328L;
    		data[38]=281474976710656L;
    		data[46]=30788473061376L;
    		return data;
    	}
    	public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
    	private static final long[] mk_tokenSet_16() {
    		long[] data = new long[48];
    		data[0]=4611686018427387904L;
    		return data;
    	}
    	public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
    	private static final long[] mk_tokenSet_17() {
    		long[] data = new long[48];
    		data[0]=4611686018427387920L;
    		data[8]=512L;
    		data[14]=4194304L;
    		return data;
    	}
    	public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
    	private static final long[] mk_tokenSet_18() {
    		long[] data = new long[94];
    		data[0]=-306772540242526192L;
    		data[1]=485119L;
    		data[8]=72339069014639104L;
    		data[9]=134217728L;
    		data[10]=576460752307617792L;
    		data[11]=262144L;
    		data[14]=2151743488L;
    		data[17]=183500800L;
    		data[20]=8192L;
    		data[21]=2251799813685248L;
    		data[24]=1152921504606846976L;
    		data[25]=4398046511104L;
    		data[26]=-9223372036854775808L;
    		data[27]=9007199254740992L;
    		data[28]=6144L;
    		data[29]=4294967296L;
    		data[31]=562949953421312L;
    		data[32]=576601489791778816L;
    		data[40]=8192L;
    		data[46]=17592186044416L;
    		return data;
    	}
    	public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
    	private static final long[] mk_tokenSet_19() {
    		long[] data = new long[48];
    		data[0]=18014398509481984L;
    		return data;
    	}
    	public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());

    	}