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] <schema_dump_file>
* </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> <schema_dump_file> 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 ("?").
* <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 > 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());
}