ExpressionEvaluator.java
// $ANTLR 2.7.7 (20060906): "expression_evaluator.g" -> "ExpressionEvaluator.java"$
/*
** Module : ExpressionEvaluator.java
** ExpressionEvaluatorTokenTypes.java
** Abstract : provides tree walking to drive Progress 4GL expression
** evaluation
**
** Copyright (c) 2004-2019, Golden Code Development Corporation.
**
** -#- -I- --Date-- -T- --JPRM-- ----------------Description-----------------
** 001 GES 20041116 ADD @18718 WARNING, THIS IS A GENERATED FILE!!!
** DO NOT EDIT THIS FILE. The original source
** file is expression_evaluator.g!
*/
package com.goldencode.p2j.uast;
import java.io.*;
import java.lang.reflect.*;
import java.util.logging.*;
import antlr.*;
import com.goldencode.ast.*;
import com.goldencode.p2j.cfg.*;
import com.goldencode.p2j.convert.*;
import com.goldencode.util.*;
import com.goldencode.p2j.util.*;
import antlr.TreeParser;
import antlr.Token;
import antlr.collections.AST;
import antlr.RecognitionException;
import antlr.ANTLRException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.collections.impl.BitSet;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;
/**
* Recursively walks an AST generated from a valid Progress 4GL expression
* and evaluates each node to obtain the final result of the expression
* which is returned to the caller as a <code>BaseDataType</code> (wrapper).
* <p>
* The caller generates a tree is by calling the
* <code>{@link ProgressParser#expr}</code> method. The
* <code>{@link #evaluate}</code> method is called and this tree as passed as
* a parameter.
* <p>
* Starting at the root of this tree, each node is visited recursively (in a
* depth-first then left to right traversal). Each node that is visited
* must be an operator, built-in function, variable (one of the
* non-parenthesized built-in functions like <code>OPSYS</code>) or a literal
* (constant). When a leaf node is encountered, a result is calculated
* and returned. Once all children of a node are evaluated, that node's
* value is calculated and then returned as the result from that portion of
* the tree (each child of an operator is an operand and is evaluated before
* the operator's result can be calculated). Children of function nodes are
* the function parameters.
* <p>
* By rationalizing all return types as an <code>BaseDataType</code>, the
* evaluate method is made recursive. This recursive model continues until
* all subsequent calls to evaluate return. This final result is returned to
* the original caller as the result of the expression evaluation.
* <p>
* The core of the grammar is a single rule called <code>evaluate</code>.
* <p>
* Some of the node processing rules are trivial enough to inline all Java
* code necessary to calculate the return data. Other rules require helpers,
* some of which are in the <code>util</code> package (all of the Progress
* 4GL compatible wrapper processing) and one of which is a manual addition
* to this class (<code>executeCallback</code>).
* <p>
* All operators and features of expression processing for integer, decimal,
* logical, date and character data types in Progress are supported. All
* literal types (including unknown value) are supported.
* <p>
* Progress recid, rowid and handle expressions are not supported at
* this time.
* <p>
* The following operators are supported:
* <p>
* <pre>
* + (addition, unary plus, date and string concatination)
* - (subtraction, unary minus and date)
* *
* /
* modulo
* ()
* or
* and
* not
* eq
* ne
* gt
* gte
* lt
* lte
* begins
* matches
* </pre>
* <p>
* The only operators that are not supported are assignment and the where
* clause <code>contains</code>.
* <p>
* The following built-in functions are supported:
* <p>
* <pre>
* absolute
* asc
* date
* day
* dbtype (currently hard coded to return "PROGRESS")
* decimal
* encode
* entry
* etime
* exp
* fill
* index
* int64
* integer
* keyword
* keyword-all
* lc
* left-trim
* length
* log
* lookup
* maximum
* minimum
* month
* num-entries
* opsys
* propath
* proversion
* r-index
* random
* replace
* right-trim
* round
* sqrt
* string
* substitute
* substring
* time
* today
* trim
* truncate
* weekday
* year
* </pre>
* <p>
* audit-enabled, library and member are not supported.
* <p>
* All data is returned as an <code>BaseDataType</code>, so one must
* determine what the real return type is before using the returned data.
* Example:
* <pre>
* BaseDataType result = ExpressionEvaluator.evaluateExpr(expr, null, false);
*
* if (result instanceof integer)
* {
* int myResult = ((integer) result).intValue();
* do something here...
* }
* </pre>
*/
public class ExpressionEvaluator extends antlr.TreeParser implements ExpressionEvaluatorTokenTypes
{
/** Logger. */
private static final ConversionStatus LOG = ConversionStatus.get(ExpressionEvaluator.class);
/** Debug mode enabled. */
private boolean debug = false;
/**
* Stores definitions of user-defined functions/variables. May be
* <code>null</code> if no user-defined features are in use.
*/
private CallbackResolver callResolver;
/**
* Constructs an instance allowing the helper classes to be provided by
* the caller.
*
* @param resolve
* Dictionary of <code>Callback</code> definitions for user-
* defined functions or variables.
*/
public ExpressionEvaluator(CallbackResolver resolve)
{
this();
callResolver = resolve;
}
/**
* Returns the status of debug mode.
*
* @return Debug mode enabled/disabled.
*/
public boolean isDebug()
{
return debug;
}
/**
* Sets the status of debug mode.
*
* @param dbg
* <code>true</code> to enable debug mode, <code>false</code>
* to disable.
*/
public void setDebug(boolean dbg)
{
debug = dbg;
}
/**
* Provides a command line interface for an end user to drive and/or test
* this class.
* <p>
* Syntax:
* <pre>
* java.exe ExpressionEvaluator "quoted_expression" [debug]
* </pre>
* Where:
* <ul>
* <li> "quoted_expression" is a valid Progress 4GL
* expression that is surrounded by double quotes. Note: if strings
* must be specified as part of the expression, specify those
* strings using the single quote character.
* </ul>
*
* @param args
* List of command line arguments.
*/
public static void main(String[] args)
{
boolean debug = false;
String syntax = "Syntax: java.exe ExpressionEvaluator " +
"<quoted_expression> [debug]";
if (args.length < 1)
{
LOG.log(Level.SEVERE, syntax);
System.exit(-1);
}
if (args.length == 2)
{
debug = true;
}
try
{
BaseDataType result = ExpressionEvaluator.evaluateExpr(args[0],
null,
debug);
System.out.println("Result = " + result);
}
catch (Exception excpt)
{
LOG.log(Level.SEVERE, "", excpt);
}
}
/**
* Add the list of built-in functions that are supported in the
* preprocessor so that these functions can be used in preprocessor
* expressions.
*
* @param sym
* The parser's symbol resolver.
* @param cr
* The container managing all function callbacks and variable
* references.
*/
public static void addStandardFunctions(SymbolResolver sym, CallbackResolver cr)
{
cr.addCallback(sym.lookupKeyword("absolute"),
null,
"com.goldencode.p2j.util.MathOps",
"abs");
cr.addCallback(sym.lookupKeyword("asc"),
null,
"com.goldencode.p2j.util.character",
"asc");
// audit-enabled not yet supported
cr.addCallback(sym.lookupKeyword("date"),
null,
"com.goldencode.p2j.util.date",
""); // empty string means this is a constructor
cr.addCallback(sym.lookupKeyword("day"),
null,
"com.goldencode.p2j.util.date",
"day");
// this will blindly return "PROGRESS" until we add schema support to the SR for use
// here; the current SR passed in here has no schema support
cr.addCallback(sym.lookupKeyword("dbtype"),
sym,
"com.goldencode.p2j.uast.SymbolResolver",
"dbtype");
cr.addCallback(sym.lookupKeyword("decimal"),
null,
"com.goldencode.p2j.util.decimal",
""); // empty string means this is a constructor
cr.addCallback(sym.lookupKeyword("encode"),
null,
"com.goldencode.p2j.util.SecurityOps",
"encode");
cr.addCallback(sym.lookupKeyword("entry"),
null,
"com.goldencode.p2j.util.TextOps",
"entry");
cr.addCallback(sym.lookupKeyword("etime"),
null,
"com.goldencode.p2j.util.date",
"elapsed");
cr.addCallback(sym.lookupKeyword("exp"),
null,
"com.goldencode.p2j.util.MathOps",
"pow");
cr.addCallback(sym.lookupKeyword("fill"),
null,
"com.goldencode.p2j.util.character",
"fill");
cr.addCallback(sym.lookupKeyword("index"),
null,
"com.goldencode.p2j.util.TextOps",
"indexOf");
cr.addCallback(sym.lookupKeyword("int64"),
null,
"com.goldencode.p2j.util.int64",
""); // empty string means this is a constructor
cr.addCallback(sym.lookupKeyword("integer"),
null,
"com.goldencode.p2j.util.integer",
""); // empty string means this is a constructor
cr.addCallback(sym.lookupKeyword("keyword"),
null,
"com.goldencode.p2j.uast.ProgressAst",
"keyword");
cr.addCallback(sym.lookupKeyword("keyword-all"),
null,
"com.goldencode.p2j.uast.ProgressAst",
"keywordAll");
cr.addCallback(sym.lookupKeyword("lc"),
null,
"com.goldencode.p2j.util.TextOps",
"toLowerCase");
cr.addCallback(sym.lookupKeyword("left-trim"),
null,
"com.goldencode.p2j.util.TextOps",
"leftTrim");
cr.addCallback(sym.lookupKeyword("length"),
null,
"com.goldencode.p2j.util.TextOps",
"length");
// no support for library()
cr.addCallback(sym.lookupKeyword("log"),
null,
"com.goldencode.p2j.util.MathOps",
"log");
cr.addCallback(sym.lookupKeyword("logical"),
null,
"com.goldencode.p2j.util.logical",
""); // empty string means this is a constructor
cr.addCallback(sym.lookupKeyword("lookup"),
null,
"com.goldencode.p2j.util.TextOps",
"lookup");
cr.addCallback(sym.lookupKeyword("maximum"),
null,
"com.goldencode.p2j.util.CompareOps",
"maximum");
// no support for member()
cr.addCallback(sym.lookupKeyword("minimum"),
null,
"com.goldencode.p2j.util.CompareOps",
"minimum");
cr.addCallback(sym.lookupKeyword("month"),
null,
"com.goldencode.p2j.util.date",
"month");
cr.addCallback(sym.lookupKeyword("num-entries"),
null,
"com.goldencode.p2j.util.TextOps",
"numEntries");
cr.addCallback(sym.lookupKeyword("opsys"),
null,
"com.goldencode.p2j.util.EnvironmentOps",
"getOperatingSystem");
cr.addCallback(sym.lookupKeyword("propath"),
null,
"com.goldencode.p2j.util.EnvironmentOps",
"getSearchPath");
cr.addCallback(sym.lookupKeyword("proversion"),
null,
"com.goldencode.p2j.util.EnvironmentOps",
"getVersion");
cr.addCallback(sym.lookupKeyword("random"),
null,
"com.goldencode.p2j.util.MathOps",
"random");
cr.addCallback(sym.lookupKeyword("replace"),
null,
"com.goldencode.p2j.util.TextOps",
"replaceAll");
cr.addCallback(sym.lookupKeyword("right-trim"),
null,
"com.goldencode.p2j.util.TextOps",
"rightTrim");
cr.addCallback(sym.lookupKeyword("r-index"),
null,
"com.goldencode.p2j.util.character",
"lastIndexOf");
cr.addCallback(sym.lookupKeyword("round"),
null,
"com.goldencode.p2j.util.MathOps",
"round");
cr.addCallback(sym.lookupKeyword("sqrt"),
null,
"com.goldencode.p2j.util.MathOps",
"sqrt");
cr.addCallback(sym.lookupKeyword("string"),
null,
"com.goldencode.p2j.util.character",
"valueOf");
cr.addCallback(sym.lookupKeyword("substitute"),
null,
"com.goldencode.p2j.util.TextOps",
"substitute");
cr.addCallback(sym.lookupKeyword("substring"),
null,
"com.goldencode.p2j.util.TextOps",
"substring");
cr.addCallback(sym.lookupKeyword("time"),
null,
"com.goldencode.p2j.util.date",
"secondsSinceMidnight");
cr.addCallback(sym.lookupKeyword("today"),
null,
"com.goldencode.p2j.util.date",
""); // empty string means this is a constructor
cr.addCallback(sym.lookupKeyword("trim"),
null,
"com.goldencode.p2j.util.TextOps",
"trim");
cr.addCallback(sym.lookupKeyword("truncate"),
null,
"com.goldencode.p2j.util.MathOps",
"truncate");
cr.addCallback(sym.lookupKeyword("weekday"),
null,
"com.goldencode.p2j.util.date",
"weekday");
cr.addCallback(sym.lookupKeyword("year"),
null,
"com.goldencode.p2j.util.date",
"year");
}
/**
* External entry point to evaluates a Progress 4GL expression as
* expressed in a string of source code.
* <p>
* Optionally user-defined functions and variables can be provided via
* a <code>CallbackResolver</code> object.
* <p>
* All data is returned as a <code>BaseDataType</code>, so one must
* determine what the real return type is before using the returned data.
* Example:
* <pre>
* BaseDataType result = ExpressionEvaluator.evaluateExpr(expr, null, false);
*
* if (result instanceof integer)
* {
* int myResult = ((integer) result).intValue();
* do something here...
* }
* </pre>
*
* @param exp
* Progress 4GL expression to evaluate.
* @param cr
* Instance of <code>CallbackResolver</code> configured with
* <code>Callback</code> objects representing the functions
* and variables to resolve. If set to <code>null</code> then
* no user-defined callbacks will be defined.
* @param debug
* If true, the expression evaluator will output debugging
* information to <code>stdout</code>. Otherwise no output
* is generated.
*
* @return The result of the expression validation or <code>null</code>
* on error.
*/
public static BaseDataType evaluateExpr(String exp, CallbackResolver cr, boolean debug)
{
BaseDataType result = null;
try
{
// initial setup (warning, schema dictionary support is disabled
// but basic lvalue processing in the parser should still be safe
// since the symbol resolver handles this case)
SymbolResolver sym = new SymbolResolver(false, true, null, true, false, null);
StringReader expr = new StringReader("(" + exp + ")");
ProgressLexer lexer = new ProgressLexer(expr, sym);
ProgressParser parser = new ProgressParser(lexer, sym);
parser.setEvaluatingExpression(true);
// if one is not provided, we must create one to hold our built-in
// functions
if (cr == null)
{
cr = new CallbackResolver();
}
// populate the CR with the standard built-in functions
// (this MUST be done after the lexer is initialized above otherwise
// any conflicts will be blown away)
addStandardFunctions(sym, cr);
// populate SymbolResolver with all Keywords in the CallbackResolver
cr.populateSymbolResolver(sym);
// parse it and create a tree
parser.expr();
CommonAST parseTree = (CommonAST) parser.getAST();
// evaluate the tree
ExpressionEvaluator expression = new ExpressionEvaluator(cr);
expression.setDebug(debug);
result = expression.evaluate(parseTree);
}
catch (Exception excpt)
{
if (debug)
{
LOG.log(Level.FINE, "", excpt);
}
}
return result;
}
/**
* This is the worker function that indirectly calls (through reflection)
* the method that matches the text in the <code>AST</code>. This
* function manually processes a subtree starting at the function's
* node. All children are manually walked and the each child is
* evaluated to obtain the result. As the depth of the subtree for
* each child is arbitrary (each parameter can be a valid Progress 4GL
* expression of arbitrary complexity), the <code>{@link #evaluate}</code>
* function is used to recursively process these expressions until the
* result is returned as an <code>Object</code>. This is assigned to
* the function call's array of arguments. In addition, each of these
* arguments is queried for its' class and this class is stored in an
* array that represents the signature of the method. Once all arguments
* and the signature are collected, the <code>CallbackResolver</code> is
* used to invoke the callback that matches the function's text.
* <p>
* On the receiving end, each parameter is unpacked into its' primitive
* form if available. The method executes and returns as it normally
* would. Reflection handles returning the result. Note that the result
* must be some form of <code>BaseDataType</code>.
* <p>
* Note that there are a large number of potential failures in the
* reflection lookup and execution process. This method passes these
* exceptions through.
* <p>
* At this time the <code>returnType</code> is not used but it may be
* used by the <code>lookupCallback</code> in the future. This is here
* since the Java reflection interfaces are expected to change to require
* this.
*
* @see #evaluate(AST)
* @see CallbackResolver#lookupCallback
*
* @param function
* Node representing the function to be executed.
* @param returnType
* Return data type represented as a class.
*
* @return Return data from the method call.
*/
private BaseDataType executeCallback(AST function, Class returnType)
throws UnsupportedOperationException,
RecognitionException,
NullPointerException,
ReflectiveOperationException
{
return executeCallback(function, returnType, false, 0);
}
/**
* This is the worker function that indirectly calls (through reflection)
* the method that matches the text in the <code>AST</code>. This
* function manually processes a subtree starting at the function's
* node. All children are manually walked and the each child is
* evaluated to obtain the result. As the depth of the subtree for
* each child is arbitrary (each parameter can be a valid Progress 4GL
* expression of arbitrary complexity), the <code>{@link #evaluate}</code>
* function is used to recursively process these expressions until the
* result is returned as an <code>Object</code>. This is assigned to
* the function call's array of arguments. In addition, each of these
* arguments is queried for its' class and this class is stored in an
* array that represents the signature of the method. Once all arguments
* and the signature are collected, the <code>CallbackResolver</code> is
* used to invoke the callback that matches the function's text.
* <p>
* On the receiving end, each parameter is unpacked into its' primitive
* form if available. The method executes and returns as it normally
* would. Reflection handles returning the result. Note that the result
* must be some form of <code>BaseDataType</code>.
* <p>
* Note that there are a large number of potential failures in the
* reflection lookup and execution process. This method passes these
* exceptions through.
* <p>
* At this time the <code>returnType</code> is not used but it may be
* used by the <code>lookupCallback</code> in the future. This is here
* since the Java reflection interfaces are expected to change to require
* this.
*
* @see #evaluate(AST)
* @see CallbackResolver#lookupCallback
*
* @param function
* Node representing the function to be executed.
* @param returnType
* Return data type represented as a class.
* @param varargs
* <code>true</code> to shift the parameters into an array
* form that can be used with method signatures that handle
* variable arguments by passing a last parameter as an array
* of objects.
* @param argIdx
* The parameter number (0-based, counting from the "left") with
* which to start the variable portion of the arguments (only
* used if <code>varargs</code> is <code>true</code>).
*
* @return Return data from the method call.
*/
private BaseDataType executeCallback(AST function,
Class returnType,
boolean varargs,
int argIdx)
throws UnsupportedOperationException,
RecognitionException,
NullPointerException,
ReflectiveOperationException
{
int num = function.getNumberOfChildren();
Object[] args = new Object[num];
Class[] signature = new Class[num];
AST child = function.getFirstChild();
boolean undef = false;
// build up the function call parameters by evaluating each child
// in order
for (int i = 0; i < num; i++)
{
args[i] = evaluate(child);
if (args[i] == null)
undef = true;
else
signature[i] = args[i].getClass();
child = child.getNextSibling();
}
if (undef)
{
signature = new Class[0];
args = new Object[0];
}
if (varargs)
{
int vsz = args.length - argIdx;
Object[] bcopy = new Object[argIdx + 1];
Class[] scopy = new Class[argIdx + 1];
BaseDataType[] vcopy = new BaseDataType[vsz];
for (int j = 0; j < args.length; j++)
{
if (j < argIdx)
{
// the base copy and signature copy will always have the same
// 0-based indexes as args and signature so j is already
// correct
bcopy[j] = args[j];
scopy[j] = signature[j];
}
else
{
// the varargs copy may have an offset index position (if
// argIdx > 0)
vcopy[j - argIdx] = (BaseDataType) args[j];
}
}
// the args have been split (if needed) and now we need to ensure
// that the variable portion is the last element (if argIdx == 0
// then this is the only element)
bcopy[argIdx] = vcopy;
// switch our arguments to the modified version
args = bcopy;
// ensure the last (or only if argIdx == 0) element of the signature
// represents the var args (an array of BDT values)
scopy[argIdx] = (new BaseDataType[0]).getClass();
// switch our signature to the modified version
signature = scopy;
}
Object res = callResolver.invokeCallback(function.getText(),
returnType,
signature,
args);
if (!(res instanceof BaseDataType))
{
// try some simple conversions
if (res instanceof Integer)
{
res = new integer((Integer) res);
}
else if (res instanceof Double)
{
res = new decimal((Double) res);
}
else if (res instanceof Boolean)
{
res = new logical((Boolean) res);
}
else if (res instanceof String)
{
res = new character((String) res);
}
else
{
throw new ClassCastException("Can't convert " +
res.getClass().getName() +
"to BaseDataType!");
}
}
return (BaseDataType) res;
}
public ExpressionEvaluator() {
tokenNames = _tokenNames;
}
/**
* Core method that does the following:
* <ul>
* <li> ensures that all alternatives recursively call this same method
* for all child nodes
* <li> forces the return type to <code>BaseDataType</code> and where
* necessary wraps and/or casts the data into the proper non-primitive
* objects for a proper return
* <li> specifies all possible alternatives and for each one, the proper
* processing is either executed inline or is accessed in another
* method or class
* </ul>
*
* @param _t
* The tree node to be recursively evaluated.
*
* @return The result of the evaluation of the subtree rooted at the node
* passed as a parameter. This result is wrapped (if necessary) in
* a <code>BaseDataType</code> before returning.
*/
public final BaseDataType evaluate(AST _t) throws RecognitionException, RecognitionException,UnsupportedOperationException,NullPointerException,ReflectiveOperationException {
BaseDataType r;
AST evaluate_AST_in = (_t == ASTNULL) ? null : (AST)_t;
AST n = null;
AST hx = null;
AST d = null;
AST da = null;
AST s = null;
AST fp = null;
AST fi = null;
AST vi = null;
AST fd = null;
AST vd = null;
AST fb = null;
AST vb = null;
AST fda = null;
AST vda = null;
AST fdt = null;
AST vdt = null;
AST fdz = null;
AST vdz = null;
AST fc = null;
AST vc = null;
int num = _t.getNumberOfChildren();
// operator processing needs its operands, do this in 1 place
final AST a = num > 0 ? _t.getFirstChild() : null;
final AST b = num > 1 ? a.getNextSibling() : null;
BaseDataType op1 = null;
BaseDataType op2 = null;
boolean varargs = false;
int ot = 0;
int aindx = 0;
r = null;
if (isDebug() && _t != null)
System.out.println(_tokenNames[_t.getType()]);
try { // for error handling
if (_t==null) _t=ASTNULL;
switch ( _t.getType()) {
case KW_OR:
{
AST tmp1_AST_in = (AST)_t;
match(_t,KW_OR);
_t = _t.getNextSibling();
LogicalOp lo = new LogicalOp()
{
public logical evaluate()
{
logical l = null;
try
{
l = (logical) ExpressionEvaluator.this.evaluate(b);
}
catch (Exception e)
{
LOG.log(Level.SEVERE, "", e);
}
return l;
}
};
r = logical.or((logical) evaluate(a), lo);
break;
}
case KW_AND:
{
AST tmp2_AST_in = (AST)_t;
match(_t,KW_AND);
_t = _t.getNextSibling();
LogicalOp lo = new LogicalOp()
{
public logical evaluate()
{
logical l = null;
try
{
l = (logical) ExpressionEvaluator.this.evaluate(b);
}
catch (Exception e)
{
LOG.log(Level.SEVERE, "", e);
}
return l;
}
};
r = logical.and((logical) evaluate(a), lo);
break;
}
case KW_NOT:
{
AST tmp3_AST_in = (AST)_t;
match(_t,KW_NOT);
_t = _t.getNextSibling();
r = logical.not((logical) evaluate(a));
break;
}
case EQUALS:
{
AST tmp4_AST_in = (AST)_t;
match(_t,EQUALS);
_t = _t.getNextSibling();
r = CompareOps.isEqual(evaluate(a), evaluate(b));
break;
}
case NOT_EQ:
{
AST tmp5_AST_in = (AST)_t;
match(_t,NOT_EQ);
_t = _t.getNextSibling();
r = CompareOps.isNotEqual(evaluate(a), evaluate(b));
break;
}
case GT:
{
AST tmp6_AST_in = (AST)_t;
match(_t,GT);
_t = _t.getNextSibling();
r = CompareOps.isGreaterThan(evaluate(a), evaluate(b));
break;
}
case LT:
{
AST tmp7_AST_in = (AST)_t;
match(_t,LT);
_t = _t.getNextSibling();
r = CompareOps.isLessThan(evaluate(a), evaluate(b));
break;
}
case GTE:
{
AST tmp8_AST_in = (AST)_t;
match(_t,GTE);
_t = _t.getNextSibling();
r = CompareOps.isGreaterThanOrEqual(evaluate(a), evaluate(b));
break;
}
case LTE:
{
AST tmp9_AST_in = (AST)_t;
match(_t,LTE);
_t = _t.getNextSibling();
r = CompareOps.isLessThanOrEqual(evaluate(a), evaluate(b));
break;
}
case KW_BEGINS:
{
AST tmp10_AST_in = (AST)_t;
match(_t,KW_BEGINS);
_t = _t.getNextSibling();
r = TextOps.begins((Text) evaluate(a), (character) evaluate(b));
break;
}
case KW_MATCHES:
{
AST tmp11_AST_in = (AST)_t;
match(_t,KW_MATCHES);
_t = _t.getNextSibling();
boolean windows = !Configuration.getParameter("unix-escapes", true);
r = TextOps.matches((Text) evaluate(a), (character) evaluate(b), windows);
break;
}
case PLUS:
{
AST tmp12_AST_in = (AST)_t;
match(_t,PLUS);
_t = _t.getNextSibling();
op1 = evaluate(a);
op2 = evaluate(b);
if (op1 instanceof NumberType)
{
r = MathOps.plus((NumberType) op1, (NumberType) op2);
}
else if (op1 instanceof character)
{
r = TextOps.concat((Text) op1, (Text) op2);
}
else
{
// assume this is a date + number
if (op2 instanceof integer)
{
r = date.plusDays((date) op1, (integer) op2);
}
else
{
r = date.plusDays((date) op1, (decimal) op2);
}
}
break;
}
case MINUS:
{
AST tmp13_AST_in = (AST)_t;
match(_t,MINUS);
_t = _t.getNextSibling();
op1 = evaluate(a);
op2 = evaluate(b);
if (op1 instanceof NumberType)
{
r = MathOps.minus((NumberType) op1, (NumberType) op2);
}
else
{
// assume this is a date - number
if (op2 instanceof integer)
{
r = date.minusDays((date) op1, (integer) op2);
}
else
{
r = date.minusDays((date) op1, (decimal) op2);
}
}
break;
}
case MULTIPLY:
{
AST tmp14_AST_in = (AST)_t;
match(_t,MULTIPLY);
_t = _t.getNextSibling();
r = MathOps.multiply((NumberType) evaluate(a),
(NumberType) evaluate(b));
break;
}
case DIVIDE:
{
AST tmp15_AST_in = (AST)_t;
match(_t,DIVIDE);
_t = _t.getNextSibling();
r = MathOps.divide((NumberType) evaluate(a),
(NumberType) evaluate(b));
break;
}
case KW_MOD:
{
AST tmp16_AST_in = (AST)_t;
match(_t,KW_MOD);
_t = _t.getNextSibling();
r = MathOps.modulo((NumberType) evaluate(a),
(NumberType) evaluate(b));
break;
}
case UN_MINUS:
{
AST tmp17_AST_in = (AST)_t;
match(_t,UN_MINUS);
_t = _t.getNextSibling();
op1 = evaluate(a);
if (op1 instanceof integer)
{
r = MathOps.negate((integer) op1);
}
else
{
r = MathOps.negate((decimal) op1);
}
break;
}
case UN_PLUS:
{
AST tmp18_AST_in = (AST)_t;
match(_t,UN_PLUS);
_t = _t.getNextSibling();
r = evaluate(a);
break;
}
case LPARENS:
{
AST tmp19_AST_in = (AST)_t;
match(_t,LPARENS);
_t = _t.getNextSibling();
r = evaluate(a);
break;
}
case UNKNOWN_VAL:
{
AST tmp20_AST_in = (AST)_t;
match(_t,UNKNOWN_VAL);
_t = _t.getNextSibling();
r = new unknown();
break;
}
case NUM_LITERAL:
{
n = (AST)_t;
match(_t,NUM_LITERAL);
_t = _t.getNextSibling();
r = new integer(n.getText());
break;
}
case HEX_LITERAL:
{
hx = (AST)_t;
match(_t,HEX_LITERAL);
_t = _t.getNextSibling();
r = decimal.fromUnsignedHexLiteral(hx.getText());
break;
}
case DEC_LITERAL:
{
d = (AST)_t;
match(_t,DEC_LITERAL);
_t = _t.getNextSibling();
r = new decimal(d.getText());
break;
}
case BOOL_TRUE:
{
AST tmp21_AST_in = (AST)_t;
match(_t,BOOL_TRUE);
_t = _t.getNextSibling();
r = new logical(true);
break;
}
case BOOL_FALSE:
{
AST tmp22_AST_in = (AST)_t;
match(_t,BOOL_FALSE);
_t = _t.getNextSibling();
r = new logical(false);
break;
}
case DATE_LITERAL:
{
da = (AST)_t;
match(_t,DATE_LITERAL);
_t = _t.getNextSibling();
r = new date(da.getText());
break;
}
case STRING:
{
s = (AST)_t;
match(_t,STRING);
_t = _t.getNextSibling();
String str = character.progressToJavaString(s.getText());
str = StringHelper.processEscapes(str);
str = StringHelper.stripMatchedComments(str);
r = new character(str);
break;
}
case FUNC_POLY:
{
fp = (AST)_t;
match(_t,FUNC_POLY);
_t = _t.getNextSibling();
aindx = 0;
varargs = false;
Aast poly = (Aast) fp;
if (poly.isAnnotation("oldtype"))
{
ot = ((Long) poly.getAnnotation("oldtype")).intValue();
if (ot == KW_MIN || ot == KW_MAX)
{
varargs = true;
}
}
r = executeCallback(fp, null, varargs, aindx);
break;
}
case FUNC_INT:
{
fi = (AST)_t;
match(_t,FUNC_INT);
_t = _t.getNextSibling();
r = executeCallback(fi, integer.class);
break;
}
case VAR_INT:
{
vi = (AST)_t;
match(_t,VAR_INT);
_t = _t.getNextSibling();
r = executeCallback(vi, integer.class);
break;
}
case FUNC_DEC:
{
fd = (AST)_t;
match(_t,FUNC_DEC);
_t = _t.getNextSibling();
r = executeCallback(fd, decimal.class);
break;
}
case VAR_DEC:
{
vd = (AST)_t;
match(_t,VAR_DEC);
_t = _t.getNextSibling();
r = executeCallback(vd, decimal.class);
break;
}
case FUNC_LOGICAL:
{
fb = (AST)_t;
match(_t,FUNC_LOGICAL);
_t = _t.getNextSibling();
r = executeCallback(fb, logical.class);
break;
}
case VAR_LOGICAL:
{
vb = (AST)_t;
match(_t,VAR_LOGICAL);
_t = _t.getNextSibling();
r = executeCallback(vb, logical.class);
break;
}
case FUNC_DATE:
{
fda = (AST)_t;
match(_t,FUNC_DATE);
_t = _t.getNextSibling();
r = executeCallback(fda, date.class);
break;
}
case VAR_DATE:
{
vda = (AST)_t;
match(_t,VAR_DATE);
_t = _t.getNextSibling();
r = executeCallback(vda, date.class);
break;
}
case FUNC_DATETIME:
{
fdt = (AST)_t;
match(_t,FUNC_DATETIME);
_t = _t.getNextSibling();
r = executeCallback(fdt, datetime.class);
break;
}
case VAR_DATETIME:
{
vdt = (AST)_t;
match(_t,VAR_DATETIME);
_t = _t.getNextSibling();
r = executeCallback(vdt, datetime.class);
break;
}
case FUNC_DATETIME_TZ:
{
fdz = (AST)_t;
match(_t,FUNC_DATETIME_TZ);
_t = _t.getNextSibling();
r = executeCallback(fdz, datetimetz.class);
break;
}
case VAR_DATETIME_TZ:
{
vdz = (AST)_t;
match(_t,VAR_DATETIME_TZ);
_t = _t.getNextSibling();
r = executeCallback(vdz, datetimetz.class);
break;
}
case FUNC_CHAR:
{
fc = (AST)_t;
match(_t,FUNC_CHAR);
_t = _t.getNextSibling();
aindx = 0;
varargs = false;
Aast fchar = (Aast) fc;
if (fchar.isAnnotation("oldtype"))
{
ot = ((Long) fchar.getAnnotation("oldtype")).intValue();
if (ot == KW_SUBSTIT)
{
aindx = 1;
varargs = true;
}
}
r = executeCallback(fc, character.class, varargs, aindx);
break;
}
case VAR_CHAR:
{
vc = (AST)_t;
match(_t,VAR_CHAR);
_t = _t.getNextSibling();
r = executeCallback(vc, character.class);
break;
}
case SYMBOL:
{
AST tmp23_AST_in = (AST)_t;
match(_t,SYMBOL);
_t = _t.getNextSibling();
break;
}
case DB_SYMBOL:
{
AST tmp24_AST_in = (AST)_t;
match(_t,DB_SYMBOL);
_t = _t.getNextSibling();
break;
}
case FILENAME:
{
AST tmp25_AST_in = (AST)_t;
match(_t,FILENAME);
_t = _t.getNextSibling();
break;
}
default:
{
throw new NoViableAltException(_t);
}
}
}
catch (RecognitionException ex) {
reportError(ex);
if (_t!=null) {_t = _t.getNextSibling();}
}
_retTree = _t;
return r;
}
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"
};
}