ProgressParser.java
// $ANTLR 2.7.7 (20060906): "progress.g" -> "ProgressParser.java"$
/*
** Module : ProgressParser.java
** ProgressParserTokenTypes.java
** ProgressLexer.java
** Abstract : lex and parse Progress 4GL source code
**
** Copyright (c) 2004-2024, Golden Code Development Corporation.
**
** -#- -I- --Date-- --JPRM-- ----------------------------------Description-----------------------------------
** 001 GES 20041116 @18747 WARNING, THIS IS A GENERATED FILE!!! DO NOT EDIT THIS FILE. The original source
** file is progress.g!
*/
package com.goldencode.p2j.uast;
import java.io.*;
import java.util.*;
import java.util.function.*;
import java.util.logging.*;
import com.goldencode.ast.*;
import com.goldencode.p2j.schema.*;
import com.goldencode.util.*;
import com.goldencode.p2j.cfg.*;
import com.goldencode.p2j.convert.*;
import com.goldencode.p2j.preproc.*;
import com.goldencode.p2j.util.*;
import antlr.*;
import antlr.debug.misc.ASTFrame;
import 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;
/**
* Creates an Abstract Syntax Tree (AST) representation of a Progress 4GL
* source file from an input stream of tokens (provided by the
* {@link ProgressLexer}). More specifically, the parser does
* the following:
* <ul>
* <li> Drives the lexer by calling its' <code>nextToken</code> method.
* This method tokenizes the lexer's input stream of characters and
* returns the next found <code>Token</code> object.
* <li> Provides a set of methods designed as entry points. The entry
* points control the type of parsing that will occur. At this time
* there are 2 valid entry points:
* <ul>
* <li> {@link #external_proc} - this is designed to
* parse an entire <b>(already preprocessed)</b> Progress 4GL
* source file
* <li> {@link #expr} - designed to parse any valid
* Progress 4GL expression
* </ul>
* <li> Recognizes the following Progress 4GL language features:
* <ul>
* <li> full expression processing for all data types
* <li> support for the data types character, logical, date, integer,
* decimal, handle, widget-handle (this type is actually
* rewritten by the lexer as a handle), raw, recid, rowid,
* memptr and com-handle
* <li> structural features such as blocks, external procedures,
* internal procedures and functions
* <li> variables, labels, procedure names, widgets, function names
* streams, menus, sub-menus, menu-items and language keywords
* (including handling abbreviations and reserved keywords)
* <li> schema object support (database, table and field names)
* <li> assignment statements including lvalue processing
* <li> language statements
* <li> attribute and method support
* <li> built-in functions (including those that act like variables
* or which have unusual syntax like postfixed function names
* or no use of parenthesized parameter lists)
* <li> COM (Active-X) property and method support
* <li> ProDataSets (datasets, data-sources, data-relations)
* <li> object-oriented support (classes, interfaces, methods,
* properties, packages, data members)
* <li> directly embedded SQL
* <li> "fake" interfaces to duplicate the features that WebSpeed
* supports (PSC encodes the documented API for WebSpeed as
* 4GL source code which is included in WebSpeed applications);
* by preloading the definitions for these features directly
* in the parser, we will treat these as real built-ins and
* eliminate the need for the PSC 4GL source code to be present
* in order to parse and convert WebSpeed applications; this
* is just an extra precaution since the WebSpeed code was
* open sourced and it is probably safe to convert but we will
* try to avoid it;
* </ul>
* <li> Builds an AST ("intermediate form representation") of
* all the recognized tokens. This AST is designed for subsequent
* processing. For example, an expression AST is evaluated by the
* {@link ExpressionEvaluator} and the related helper
* class {@link ExpressionEvaluator}. The
* resulting AST matches the block structured nature of the Progress
* 4GL, including the provision of nesting and the refusal to nest
* in certain cases (e.g. Progress 4GL does not allow nesting of
* procedure or function definitions, but it does allow for the
* nesting of blocks such as <code>do</code> or <code>repeat</code>).
* <li> Handles the context sensitive aspects of symbol resolution.
* <li> To the extent that is possible while still generating a well
* structured tree, the parser has been structured to enforce
* syntactic correctness. This is typically well implemented in
* specific language statements (their structure enforces 100%
* syntactic correctness in more cases or it enforces nearly 100%
* correctness). Due to ambiguities in the Progress 4GL language and
* constraints in the ANTLR parser generation, it is not always
* possible to make the parser's structure (i.e. the manner in which
* its rules nest and how the matching of each rule processes)
* enforce syntax checks. For some language features, these checks
* must be implemented using ANTLR's semantic or syntactic predicates
* and in other cases ANTLR's actions must be used for a completely
* custom set of checks.
* </ul>
* <p>
* This grammar is highly specific to ANTLR 2.7.4 and it may not be valid
* in future versions of ANTLR. This is due to the fact that the generated
* code and the grammar syntax of ANTLR can change between versions. These
* factors are the most important constraints defining the structure of the
* resulting grammar. As a result, it is possible that the grammar will
* require changes to run in future versions of ANTLR.
* <p>
* <b>Please note that this is a generated file using ANTLR 2.7.4 and a
* grammar specified in <code>progress.g</code>.</b>
* <p>
* The generated parser is an LL(k) type parser. This means that it is
* top-down parser than recursively descends from top level rules through
* more and more specific rules until matches are found, in which case the
* token is consumed from the input stream and the rules return up one level
* to their calling rule and so on until processing completes a full top
* level match and returns all the way up to the top level entry point.
* <p>
* The top level entry points are designed to either match a single construct
* (e.g. <code>expr</code> which parses and matches a single expression) or
* to iteratively match a set of constructs that might comprise an entire
* source file (e.g. <code>external_proc</code>).
* <p>
* Starting at the top level, the parser requests the next tokens from the
* lexer in order to have the proper amount of lookahead. The lookahead
* depth defined as the "k" of the parser, and in this case the k
* = 2. These lookahead tokens are compared to sets for each alternative
* that is defined at the top level. Where there is ambiguity, the first
* match will trigger a call to the rule specified in the alternative (and/or
* it will match any hard coded tokens in the alternative). Once that
* alternative is entered, the parser expects that it will begin matching
* specified constructs at the top level or in one of the rules that will be
* recursively called. This matching consumes tokens from the lexer's stream
* so a call to these rules is a one way process which must end in a complete
* match to the set of rules that can be reached from the top level
* alternative that was predicted by the lookahead. This means that the
* prediction logic is generated at the top level (outside of the rules)
* but based on the contents of the rules. So the consolidated lookahead of
* all possible paths through the rules is rolled up into the prediction
* logic at the top level while the matching doesn't occur until the
* specific rules are recursively entered. This roll up can create sets
* of predictions that cannot actually occur in a given grammar, but which
* appear to be possible based on the rolled up prediction logic. This
* can be the source of ambiguity and hence ANTLR warnings. It is important
* to keep the top level alternatives very distinct and to organize them
* in a decreasing specificity order so that the order will naturally
* resolve ambiguity using lookahead.
* <p>
* For details on how the context sensitive symbol resolution occurs, please
* see {@link #primary_expr}, {@link #func_call}, {@link #lvalue},
* {@link #record}, {@link #label_reference} and {@link #symbol}. In
* addition, it is important to review the lexer's role in symbol resolution
* (see {@link ProgressLexer#mSYMBOL}).
* <p>
* Implementation WARNING: <b>ANTLR syntactic predicates cannot be used</b>
* because this changes how the all code is generated such that all actions
* are made conditional on the state of the guessing mode. The problem with
* this is that the parser implementation is heavily designed based on an
* assumption that all actions (especially init actions) are not conditional.
* For example, many local variables are defined in init actions. As soon as
* a single syntactic predicate is added to the parser, all init actions are
* wrapped in an if () { } block which makes any defined local variables
* immediately go out of scope and thus they are not available to the rest
* of the method. This breaks the parser.
* <p>
* Notes on understanding keyword usage: All keywords have a specific token
* type. That type is an artificially created token which exists in one of
* two ranges: <code>BEGIN_RESERVED</code> through <code>END_RESERVED</code>
* (for the reserved keywords) and <code>BEGIN_UNRESERVED</code> through
* <code>END_UNRESERVED</code> (for unreserved keywords). Then the lexer is
* modified to have a {@link Keyword} instance definition in it's list of
* keywords. These keywords are used for lookups and that processing handles
* abbreviations, case-insensitivity and other features of Progress keyword
* processing. The lexer converts symbols into keyword tokens when this
* keyword lookup is successful. Then the parser matches on the keyword
* token type as needed to match the 4GL language syntax. There are keywords
* in the list which are not represented in parser rules. This is a normal
* case for the following: events, constants, built-in function names and
* those built-in functions that act like global variables. All of those
* cases provide the keyword so that downstream tree processing can easily
* compare events, constants or the <code>oldtype</code> annotation on
* built-in functions/variables. Do NOT be disturbed by the lack of any
* usage of these tokens in the parser itself.
* <p>
* Open TODOs/Issues:
* <p>
* <ul>
* <li> stored procedure support is present but not complete
* <ul>
* <li> procedures are schema objects that act like tables in some
* ways, but have additional behavior as well, this schema support
* does not exist
* <li> the stored procedure rules must be updated to dynamically
* create the special stored procedure names when needed, likewise
* there are buffer and field definitions that must be dynamically
* created during parsing (this will use the functionality noted
* above for the schema)
* <li> see the rules {@link #run_stored_proc_stmt} and
* {@link #close_stored_proc_stmt} for more details
* </ul>
* <li> schema name lookups are documented to give preference to tables
* over temp-tables in the case where both share the same name (this
* has not necessarily been explicitly tested and it isn't obvious if
* we have intentionally or unintentionally implemented this at all);
* but in addition, the DEFINE BUFFER statement now allows one to
* specify the TEMP-TABLE keyword to force temp-tables to be preferred
* over a table of the same name
* <li> any use of the <code>NAMESPACE-URI</code> and/or
* <code>NAMESPACE-PREFIX</code> options (see
* {@link #namespace_clause}) is not honored at this time
* <li> 4GL aggregate support seems to be implemented by using hidden
* variables that are created on the fly and which can be referenced
* and assigned directly from user code (without any explicit variable
* definition code); for example the integer variable COUNT can be
* directly referenced by user code when the COUNT aggregate is in
* use; these variables, their types and the exact moment of creation
* need to be investigated and added (it is all undocumented of
* course)
* <li> {@link #form_item} has an incomplete implementation to support
* inline AS or LIKE clauses; this will not match all possible cases
* where AS or LIKE appears later in the format phrase (since they
* can be arbitrarily ordered); see <code>isFormVarDefinition()</code>
* which is some example code for a partial solution but it does not
* work completely enough to be used;
* <li> {@link #constant_form_item}, {@link #column_ref} and
* {@link #browse_options_phrase} matches a subset of the format
* phrase but these options are not rooted as a FORMAT_PHRASE node;
* they should be rooted at such a node and when that happens, there
* will be "downstream" reporting code and conversion code that needs
* to be reworked (but that code will be much simpler); as a related
* question: should the options for the various variable definition
* mechanisms be rooted at a FORMAT_PHRASE?
* <li> {@link #def_var_stmt} may need to exclude RAW and MEMPTR fields
* from adding a WID_FILL_IN definition (like it does today for
* handle types)
* <li> should INPUT-VALUE be a synonym for SCREEN-VALUE or are these
* really different values?
* <li> should we support VAR_LONGCHAR and FIELD_CLOB in
* {@link #choose_keys_clause}?
* <li> confirm that properties and class data members (variables) share
* the same namespace as is suggested by the documentation
* <li> buffers, queries, temp-tables, prodatasets and data-sources can
* be protected resources of a parent class that are accessed from
* a child class; this is not implemented at this time and some
* example code is needed to fully demonstrate the requirements
* before implementation (this will affect the schema dictionary and
* the symbol resolver's resource lookup processing and loadViaWalk()
* method)
* <li> since the parser now provides "fake" interfaces to duplicate
* the features that WebSpeed supports, that support may not have
* been completely documented by PSC and as such it may not be
* complete
* <ul>
* <li> there are references in the WebSpeed documentation to variable
* names like "SelfURL", "AppURL" and CGI environment variables
* but there are no details on the types or usage of these, so at
* this time these are not yet added but may subsequently be found
* in real source code
* <li> it is likely that the features of HTML mapping and session
* management may provide procedures and functions that are not
* documented but which are used in real source code
* </ul>
* </ul>
*/
public class ProgressParser extends antlr.LLkParser implements ProgressParserTokenTypes
{
/** Logger. */
private static final ConversionStatus LOG = ConversionStatus.get(ProgressParser.class);
/** Our instance of the AstGenerator, if any. */
private AstGenerator gen = null;
/** Name of the specialized AST class to use when parsing. */
private static final Class AST_CLASS = ProgressAst.class;
/** Provides an efficient reverse lookup of names to token types. */
private static Map tokenLookup = null;
/** Debug mode for the parser. */
private boolean debug = false;
/** Tracks the nesting level of procedures and functions. */
private int nestLevel = 0;
/** Tracks the number of statements within a constructor. */
private int constStmts = -1;
/**
* Contains all symbol resolution dictionaries and provides the
* maintenance/lookup methods.
*/
private SymbolResolver sym = null;
/**
* Sets the bias in {@link #lvalue} toward (if <code>true</code>) or
* away from (if <code>false</code>) widgets. Defaults to
* <code>false</code>.
*/
private boolean preferWidgets = false;
/** Class name to use in {@link #lvalue} for data member lookups. */
private String currentClassName = null;
/** Flag to use in {@link #lvalue} for static-only data member lookups. */
private boolean currentStaticFlag = false;
/** Flag used in {@link #chained_object_members} for handling of widget qualifiers in dynamic-function. */
private boolean inDynFunc = false;
/**
* Modify {@link #lvalue} processing when called from inside the
* {@link #primary_expr} rule.
*/
// private boolean inPrimaryExpr = false;
/**
* Modify {@link #lvalue} field annotations and {@link #subscript}
* processing when inside a <code>LIKE</code> clause.
*/
private boolean inLikeClause = false;
/**
* Modify {@link #lvalue} field annotations and {@link #subscript}
* processing when inside a <code>FORM</code> clause.
*/
private boolean inFormStatement = false;
/** The current record being processed in this query. */
private NameNode currentRecord = null;
/** Modify {@link #expr} process when inside embedded SQL statements. */
private boolean embeddedSql = false;
/** Tracks the number of times an SQL UNION statement is nested. */
private int sqlNestLevel = 0;
/** Tracks the number of times an SQL SELECT statement is nested. */
private int selectNestLevel = 0;
/** <code>true</code> if processing an SQL UNION statement. */
private boolean inUnion = false;
/**
* The name of the database field being currently processed for possible
* validation.
*/
private String validateFieldName = null;
/** <code>true</code> if a validate expression is being processed. */
private boolean validation = false;
/**
* The complete text (including hidden token text) for the combined tokens when the field name
* quirk is fixed up.
*/
private String fieldNameQuirkOriginalText = null;
/**
* Set to <code>false</code> when the parser is currently in an internal
* procedure, function or trigger, otherwise is set <code>true</code>.
*/
private boolean bufferScope = true;
/** Prefer temp-tables where the name conflicts with a table. */
private boolean forceTemp = false;
/** Prefer persistent tables where the name conflicts with a temp-table. */
private boolean forcePersistent = false;
/** Are we parsing code inside a method definition (includes constructors, destructors...). */
private boolean inMethodDef = false;
/** <code>true</code> if the parser was entered via external_proc. */
private boolean topLevelEntry = false;
/** Greater than 0 if the parser was entered via pre_scan_class. */
private int preScanPass = 0;
/** Tracks the level of recursion in the {@link #expr} rule. */
private int exprLvl = 0;
/** <code>true</code> if parsing a WebSpeed program. */
private boolean webspeed = false;
/** <code>true</code> to consume errors and automatically restart parsing. */
private boolean consumeErr = true;
/** Determines if the parser was entered for preprocessor expression evaluation. */
private boolean evaluatingExpression = false;
/**
* Normally, the variable names are preferred when there is a collision with a field name
* (see {@link #resolveLvalueCoreType}). However, in some cases the syntax requires a
* field name (like {@link #field_mapping_clause}). Setting this value to {@code true}
* will make the parser ignore variables and choose fields instead.
*/
private boolean preferFields = false;
/** Flag to allow {@link #lvalue} to match a <code>SYMBOL</code>. */
private boolean allowSymbolMatch = false;
/** Allows matching certain unquoted text as strings. */
private boolean allowStringMatch = false;
/** Avoids matching frames as an lvalue. */
private boolean excludeFrame = false;
/** Filter implementation to allow access to hidden tokens. */
private TokenStreamHiddenTokenFilter hidden = null;
/** Allow matching an unquoted method name in special cases. */
private boolean insideClassEvent = false;
/** Flag indicating we are processing the class body. */
private boolean insideClass = false;
/** <code>true</code> if we are parsing a built-in class/interface. */
private boolean builtInCls = false;
/** <code>true</code> if we are parsing a .NET class/interface. */
private boolean dotNetCls = false;
/** <code>true</code> if we are parsing inside a static method. */
private boolean inStaticCtxt = false;
/** The number of errors encountered during parsing */
private int errorCount = 0;
/** Flag indicating that {@link #un_type} may match a real assignment. */
private boolean matchAssign = false;
/**
* Flag indicating the {@link #expr} must not emit an EXPRESSION node, regardless of
* {@code exprLvl}.
*/
private boolean skipExpression = false;
/** Honor backslashes as escape characters. */
private boolean unixEscapes = true;
/**
* <code>true</code> if fields should be scoped to the default buffer. This is used in <code>FORM</code>
* and <code>DEFINE FRAME</code> for unqualified lookups of fields.
*/
private boolean preferDefaultBuffer = false;
/**
* Constructs a parser using a lexer and a user-defined symbol resolver.
* This method ensures that the symbol resolver's function and variable
* dictionaries are preloaded with the built-in symbols of the Progress
* language. This preloading must occur before parsing can begin.
*
* @param lexer
* An instance of a <code>TokenStream</code> object.
* @param sr
* The user-defined (and optionally preloaded) symbol resolver.
*/
public ProgressParser(TokenStream lexer, SymbolResolver sr)
{
// init our parent class
this(lexer, 3);
// shift into filter mode
hidden = new ManagedHiddenStreamTokenFilter(lexer);
setTokenBuffer(new TokenBuffer(hidden));
// setup the lexer
((ProgressLexer)lexer).activateHiddenProcessing();
unixEscapes = ((ProgressLexer)lexer).isUnixEscapes();
setupHiddenFilter();
// setup our resolver
sym = sr;
initializeProcedureDictionary();
initializeStreamDictionary();
initializeFunctionDictionary();
initializeVariableDictionary();
initializeAttributesDictionary();
honorKeywordIgnoreList(((ProgressLexer)lexer).getIgnoredKeywords());
// set the AST class
astFactory.setASTNodeClass(AST_CLASS);
}
/**
* Writes error data to logger, including a full stack trace.
*
* @param re
* The error on which to report.
*/
public void reportError(RecognitionException re)
{
// keep the total error count
errorCount++;
if (consumeErr)
{
// pre_scan_class needs more detail otherwise the error is hard to find
if (preScanPass > 0)
{
try
{
CommonToken tok = (CommonToken) LT(1);
System.out.println(
String.format("pre_scan_class failure with text '%s', error '%s' at line %d," +
" column %d in file %s",
tok.getText(),
re.getMessage(),
tok.getLine(),
tok.getColumn(),
getFilename()));
}
catch (TokenStreamException e)
{
// ignore
}
}
// print the error info, consume the exception then restart parsing
LOG.log(Level.SEVERE, "", re);
}
else
{
// don't consume the error and don't restart parsing
throw new RuntimeException(re);
}
}
/**
* Helper to package up an error message and the no-viable-alternative location details
* into a single exception instance.
*
* @param msg
* Error message for the containing <code>RuntimeException</code>
* @param node
* AST node which provides context for the no-viable-alternative location details.
*
* @return The exception.
*/
public RuntimeException genExc(String msg, Aast node)
{
AnnotatedAst ast = (AnnotatedAst) node;
return new RuntimeException(msg, new NoViableAltException(ast));
}
/**
* Helper to package up an error message and the no-viable-alternative location details
* into a single exception instance.
*
* @param msg
* Error message for the containing <code>RuntimeException</code>
* @param node
* Token node which provides context for the no-viable-alternative location details.
*
* @return The exception.
*/
public RuntimeException genExc(String msg, Token node)
{
return new RuntimeException(msg, new NoViableAltException(node, getFilename()));
}
/**
* Tests if debug is turned on.
*/
public boolean isDebug()
{
return debug;
}
/**
* Sets the status of the debug mode member.
*
* @param debug
* <code>true</code> to enable debug output.
*/
public void setDebug(boolean debug)
{
this.debug = debug;
}
/**
* Method to expose the AstGenerator, if any.
*
* @param gen
* The generator that is driving this run.
*/
public void setGenerator(AstGenerator gen)
{
this.gen = gen;
}
/**
* Tests if the consume error flag is turned on.
*/
public boolean isConsumeError()
{
return consumeErr;
}
/**
* Sets the status of the consume error flag.
*
* @param consume
* <code>true</code> to enable debug output.
*/
public void setConsumeError(boolean consume)
{
this.consumeErr = consume;
}
/**
* Gets the status of the expression evaluation member.
*/
public boolean isEvaluatingExpression()
{
return evaluatingExpression;
}
/**
* Sets the status of the expression evaluation member.
*
* @param eval
* <code>true</code> if the current code is used to evaluate
* an expression.
*/
public void setEvaluatingExpression(boolean eval)
{
evaluatingExpression = eval;
}
/**
* Tests if this is parsing a WebSpeed program.
*/
public boolean isWebSpeed()
{
return webspeed;
}
/**
* Sets the status of the WebSpeed parsing flag.
*
* @param webspeed
* <code>true</code> if the current program is a WebSpeed
* application.
*/
public void setWebSpeed(boolean webspeed)
{
this.webspeed = webspeed;
}
/**
* Tests if this is parsing a built-in 4GL class/interface.
*/
public boolean isBuiltInCls()
{
return builtInCls;
}
/**
* Sets the status of the built-in 4GL parsing flag.
*
* @param builtInCls
* <code>true</code> if the current program is a built-in 4GL
* class/interface.
*/
public void setBuiltInCls(boolean builtInCls)
{
this.builtInCls = builtInCls;
}
/**
* Tests if this is parsing a .NET class/interface.
*/
public boolean isDotNetCls()
{
return dotNetCls;
}
/**
* Sets the status of the .NET parsing flag.
*
* @param dotNetCls
* <code>true</code> if the current program is a .NET
* class/interface.
*/
public void setDotNetCls(boolean dotNetCls)
{
this.dotNetCls = dotNetCls;
}
/**
* Returns the number of errors encountered during parsing.
*
* @return See above.
*/
public int getErrorCount()
{
return errorCount;
}
/**
* Translates a text representation of a parser token type into the
* actual integer value.
*
* @param tokenName
* The text representation of the parser token type.
*
* @return A valid parser-defined integer token type value or -1 if
* no match was found.
*/
public static synchronized int lookupTokenType(String tokenName)
{
// one-time init when we are first called
if (tokenLookup == null)
{
int len = ProgressParser._tokenNames.length;
tokenLookup = new HashMap();
// load the map with our lowercased symbolic name as the key and
// the wrappered int token type as the value
for ( int i = 0; i < len; i++ )
{
tokenLookup.put(ProgressParser._tokenNames[i].toLowerCase(),
Integer.valueOf(i));
}
}
Integer result = (Integer) tokenLookup.get(tokenName.toLowerCase());
if (result == null)
{
return -1;
}
return result.intValue();
}
/**
* Translates an integer value of a parser token type into the associated
* human readable text representation.
*
* @param type
* The integer token type.
*
* @return A valid parser-defined symbolic name or <code>null</code> if
* no match was found.
*/
public static String lookupTokenName(int type)
{
if (type < 0 || type >= ProgressParser._tokenNames.length)
{
return null;
}
return ProgressParser._tokenNames[type];
}
/**
* Create a schema validation sub-tree if the given field reference has schema-level assign
* validation defined, and attach it to the given anchor point. If no validation expression
* exists in the schema for the given field, no change is made.
*
* @param anchor
* AST to which a KW_VALIDATE and/or KW_HELP sub-tree will be attached as a child.
* @param fieldRef
* The AST for a business logic reference to a database field. This AST is expected
* to have <code>schemaname</code> and <code>bufname</code> annotations.
* @param sym
* Symbol resolver which will be used to parse the schema validation expression, if
* any, for the given field.
*
* @return Schema validation node that was attached, if any, or <code>null</code> if nothing
* was attached.
*/
private List<Aast> attachAssignSchemaValidation(Aast anchor, Aast fieldRef, SymbolResolver sym)
{
String schemaName = (String) fieldRef.getAnnotation("schemaname");
String bufName = (String) fieldRef.getAnnotation("bufname");
Aast schemaRef = sym.lookupFieldAst(fieldRef.getText());
validateFieldName = schemaName;
List<Aast> ret = attachAssignSchemaValidation(anchor, schemaRef, schemaName, bufName, sym);
validateFieldName = null;
return ret;
}
/**
* Create a schema validation sub-tree if the given field reference has schema-level assign
* validation defined, and attach it to the given anchor point. If no validation expression
* exists in the schema for the given field, no change is made.
*
* @param anchor
* AST to which a KW_VALIDATE and/or KW_HELP sub-tree will be attached as a child.
* @param schemaRef
* The AST for a field provided by the schema dictionary, from which the validation
* expression and message are retrieved.
* @param schemaName
* Fully qualified schema name of the field for which validation is being processed.
* @param bufName
* Qualified name of the buffer referencing the table which contains the field for
* which validation is being processed.
* @param sym
* Symbol resolver which will be used to parse the schema validation expression, if
* any, for the given field.
*
* @return Schema validation node that was attached, if any, or <code>null</code> if nothing
* was attached.
*/
private List<Aast> attachAssignSchemaValidation(Aast anchor,
Aast schemaRef,
String schemaName,
String bufName,
SymbolResolver sym)
{
Aast valExp = schemaRef.getImmediateChild(VALEXP, null);
Aast valMsg = schemaRef.getImmediateChild(VALMSG, null);
String like = (String) schemaRef.getAnnotation("like");
String help = null;
if (schemaRef.isAnnotation("help"))
{
help = (String) schemaRef.getAnnotation("help");
}
else if (schemaRef.downPath(KW_HELP))
{
Aast helpRef = schemaRef.getImmediateChild(KW_HELP, null);
helpRef = (Aast) helpRef.getFirstChild();
help = helpRef.getText();
}
return attachSchemaValidation(anchor, valExp, valMsg, schemaName, bufName, like, sym, help);
}
/**
* Given a record reference, find all fields in the corresponding table for which schema-level
* assign validation is defined; create a schema validation sub-tree for each, and attach
* these sub-trees to the given anchor point. If no validation expressions exist for any of
* the fields in the table, no change is made.
*
* @param anchor
* AST to which zero or more KW_VALIDATE and/or KW_HELP sub-trees will be attached as
* children.
* @param recordRef
* The AST for a business logic reference to a database record. This AST is expected
* to have <code>schemaname</code> and <code>bufname</code> annotations.
* @param sym
* Symbol resolver which will be used to parse the schema validation expressions, if
* any, for the fields in the given table.
* @param exceptFields
* The fully-qualified names of all fields to be omitted, or <code>null</code>
* if not in use.
*/
private void attachAllAssignSchemaValidation(Aast anchor,
Aast recordRef,
SymbolResolver sym,
Set<String> exceptFields)
{
String tableSchemaName = (String) recordRef.getAnnotation("schemaname");
String bufName = (String) recordRef.getAnnotation("bufname");
Iterator<Aast> fieldIter = sym.fields(tableSchemaName);
while (fieldIter.hasNext())
{
Aast schemaRef = fieldIter.next();
String fieldSchemaName = tableSchemaName + "." + schemaRef.getText().toLowerCase();
if (exceptFields != null && exceptFields.contains(fieldSchemaName))
{
continue;
}
// build intermediate format phrase node to which to attach KW_VALIDATE nodes, if any
Aast fpRef = new ProgressAst();
fpRef.setType(FORMAT_PHRASE);
fpRef.setText("format phrase");
attachAssignSchemaValidation(fpRef, schemaRef, fieldSchemaName, bufName, sym);
// if any sub-trees were attached to format phrase node, attach it to anchor, just after
// TABLE or BUFFER node
if (fpRef.getFirstChild() != null)
{
fpRef.putAnnotation("schemaname", fieldSchemaName);
anchor.addChild(fpRef);
}
}
}
/**
* Create a schema validation sub-tree if the given record reference has schema-level delete
* validation defined, and attach it to the given anchor point. If no validation expression
* exists in the schema for the given table, no change is made.
*
* @param anchor
* AST to which a KW_VALIDATE and/or HW_HELP sub-tree will be attached as a child.
* @param recordRef
* The AST for a business logic reference to a database record. This AST is expected
* to have <code>schemaname</code> and <code>bufname</code> annotations.
* @param sym
* Symbol resolver which will be used to parse the schema validation expression, if
* any, for the given field.
*/
private void attachDeleteSchemaValidation(Aast anchor, Aast recordRef, SymbolResolver sym)
{
Aast schemaRef = sym.lookupTableAst(recordRef.getText());
Aast props = schemaRef.getImmediateChild(PROPERTIES, null);
if (props == null)
{
// some temp-/work-tables will not have a PROPERTIES node
return;
}
Aast valExp = props.getImmediateChild(VALEXP, null);
if (valExp == null)
{
return;
}
Aast valMsg = props.getImmediateChild(VALMSG, null);
String schemaName = (String) recordRef.getAnnotation("schemaname");
String bufName = (String) recordRef.getAnnotation("bufname");
String like = (String) schemaRef.getAnnotation("like");
attachSchemaValidation(anchor, valExp, valMsg, schemaName, bufName, like, sym, null);
}
/**
* Create a schema validation sub-tree for the field or record indicated by the given schema
* and buffer names, and attach it to the given anchor point. If no validation expression
* exists in the schema for the given field or record, no change is made.
*
* @param anchor
* AST to which a KW_VALIDATE and/or KW_HELP sub-tree will be attached as a child.
* @param valExp
* Validation expression AST.
* @param valMsg
* Validation message AST.
* @param schemaName
* Fully qualified schema name of database field for which validation is needed.
* @param bufName
* Name of buffer referenced in business logic, which contains field.
* @param like
* If this is a LIKE-defined field, this contains the fully-qualified source field
* name.
* @param sym
* Symbol resolver which will be used to parse the schema validation expression, if
* any, for the given field or record.
* @param help
* The schema-level help text.
*
* @return Schema validation node that was attached, if any, or <code>null</code> if nothing
* was attached.
*/
private List<Aast> attachSchemaValidation(Aast anchor,
Aast valExp,
Aast valMsg,
String schemaName,
String bufName,
String like,
SymbolResolver sym,
String help)
{
// TODO: the anchor in is not in all cases a FORMAT_PHRASE, when BROWSE DISPLAY/ENABLE is
// involved; if this gets changed, then TRPL conversion rules need to be adjusted, to work
// with the new AST structure.
boolean isFP = anchor.getType() == FORMAT_PHRASE;
List<Aast> res = new ArrayList<>();
// do not attach if there is already a KW_VALIDATE in this FORMAT_PHRASE
if (valExp != null && (!isFP || !anchor.downPath(KW_VALIDATE)))
{
// expression text is at VALEXP->STRING:text
String expText = valExp.getFirstChild().getText();
String msgText = "\"\"";
if (valMsg != null)
{
// message text is at VALMSG->EXPRESSION->STRING:text
msgText = valMsg.getFirstChild().getFirstChild().getText();
}
try
{
// preprocess text, in case there are any includes that need to be resolved
String[] paths = gen.getPaths(); // Use getter for hints RFB20190911
UastHints hints = gen.getHints(); // Use new getter for hints RFB20190911
Options options = AstGenerator.buildOptions(paths, null, hints);
StringWriter out = new StringWriter();
FileScope fs = new FileScope("<inline>", new StringReader(expText));
new Preprocessor(fs, out, new PrintWriter(System.err), null, options);
expText = out.toString();
if (expText.length() > 0)
{
// parse expText using a new Progress parser, but with the provided symbol resolver
StringReader reader = new StringReader(expText);
ProgressLexer lexer = new ProgressLexer(reader, sym);
ProgressParser parser = new ProgressParser(lexer, sym);
sym.addSchemaScope(false);
// the current table has precendence - add it first
String table = schemaName.substring(0, schemaName.indexOf('.'));
sym.promoteTableName(table, true, true);
// make all the tables in the source schema available
sym.promoteAllTables(like == null ? schemaName : like);
// make the new parser aware of the field being validated. In case of CAN-FIND,
// when resolving an unqualified field name, the [validateFieldName] takes
// precedence during parsing of this expression.
parser.validateFieldName = this.validateFieldName;
parser.validation = true;
parser.setConsumeError(false);
parser.expr();
Aast ve = (Aast) parser.getAST();
// verify if any of the VALEXP field reference is for the 'like' field - if so,
// replace the text, schemaname, etc with this field's info
sym.deleteSchemaScope(false);
String fldName = schemaName.substring(schemaName.lastIndexOf('.') + 1);
Iterator<Aast> iter = ve.iterator();
while (iter.hasNext())
{
Aast ast = iter.next();
int type = ast.getType();
if (type >= BEGIN_FIELDTYPES && type <= END_FIELDTYPES)
{
String schemaname = (String) ast.getAnnotation("schemaname");
if (like != null && like.equals(schemaname))
{
ast.putAnnotation("schemaname", schemaName);
ast.putAnnotation("bufname", bufName);
ast.removeAnnotation("dbname");
ast.putAnnotation("name", fldName);
ast.setText(fldName);
}
}
}
// add KW_VALIDATE child to anchor node
Aast valParent = new ProgressAst();
valParent.setType(KW_VALIDATE);
valParent.setText(expText);
valParent.putAnnotation("schema_validation", true);
valParent.putAnnotation("schemaname", schemaName);
valParent.putAnnotation("bufname", bufName);
anchor.addChild(valParent);
// add first EXPRESSION child to KW_VALIDATE node (for condition)
Aast exp = new ProgressAst();
exp.setType(EXPRESSION);
exp.setText("expression");
valParent.addChild(exp);
// add validation expression subtree to condition EXPRESSION node
exp.addChild(ve);
// add second EXPRESSION child to KW_VALIDATE node (for message)
exp = new ProgressAst();
exp.setType(EXPRESSION);
exp.setText("expression");
valParent.addChild(exp);
// add STRING child to message EXPRESSION node
Aast str = new ProgressAst();
str.setType(STRING);
str.setText(msgText);
exp.addChild(str);
res.add(valParent);
}
}
catch (Exception exc)
{
boolean verbose = Configuration.getParameter("broken-schema-validation-warnings", true);
if (verbose == true)
{
LOG.log(Level.WARNING, expText);
LOG.log(Level.WARNING, "Ignoring invalid schema validation expression for field '" +
schemaName +
"':", exc);
}
}
}
// do not attach if there is already a KW_HELP in this FORMAT_PHRASE; skip COLUMN_REF for
// BROWSE enable option, as HELP will be pulled automatically by conversion rules, if needed
if (help != null &&
anchor.getType() != COLUMN_REF &&
(!isFP || !anchor.downPath(KW_HELP)))
{
Aast helpAst = new ProgressAst();
helpAst.setType(KW_HELP);
helpAst.setText("help");
helpAst.putAnnotation("schema_help", true);
anchor.addChild(helpAst);
Aast str = new ProgressAst();
str.setType(STRING);
str.setText(help);
helpAst.addChild(str);
res.add(helpAst);
}
return res;
}
/**
* Matches and consumes a token that must be within a specific range of
* token types. This code is based on other matching methods provided
* by ANTLR. The ANTLR generator will properly create code to call
* this method using the ".." range operator. While the
* generated lexer does contain a <code>matchRange</code> method, the
* parser does not! This method was added manually to resolve this
* condition.
* <p>
* Note that to make this useful, one must maintain a list of the
* artificial token types (using the tokens { } section in the parser's
* grammar). More importantly, all needed tokens to be matched in a range
* need to be kept contiguous so that the range neither includes token
* types it should not, nor excludes types it should not. Since ANTLR
* generates the token types in order found in that section, one trick
* used is to add a special token to mark the begin and end of any such
* range. These can be used instead of the actual first and last tokens.
* This makes it easier to edit without introducing an error.
*/
public void matchRange( int t1, int t2 )
throws MismatchedTokenException,
TokenStreamException
{
if ( LA(1) < t1 || LA(1) > t2 )
{
throw new MismatchedTokenException(tokenNames,
LT(1),
t1,
false,
getFilename());
}
else
{
// mark token as consumed -- fetch next token deferred until LA/LT
consume();
}
}
/**
* Remove any built-in functions or global variables that are defined with the given
* keywords.
*
* @param ignored
* The list to process.
*/
private void honorKeywordIgnoreList(Keyword[] ignored)
{
if (ignored != null)
{
for (Keyword word : ignored)
{
sym.removeBuiltinFunction(word);
sym.removeGlobalVariable(word);
}
}
}
/**
* 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);
}
/**
* Check if the given token is for a statement which can act as a left-side of an assignment.
*
* @param type
* The token type.
*
* @return <code>true</code> if this token is for a statement which can act as a left-side of
* an assignment.
*/
private boolean isLstmt(long type)
{
return type == KW_CUR_VAL || type == KW_DYN_CURV || type == KW_DYN_PROP || type == KW_ENTRY ||
type == KW_EXTENT || type == KW_FIX_CP || type == KW_LENGTH || type == KW_OVERLAY ||
type == KW_PUT_BITS || type == KW_PUT_BYTE || type == KW_PUT_BYTS || type == KW_PUT_DBL ||
type == KW_PUT_FLT || type == KW_PUT_I64 || type == KW_PUT_LONG || type == KW_PUT_SHT ||
type == KW_PUT_STR || type == KW_PUT_UL || type == KW_PUT_USHT || type == KW_RAW ||
type == KW_SET_B_OR || type == KW_SET_PTR || type == KW_SET_SZ || type == KW_SUBSTR;
}
/**
* Determine if the tokens can represent a static class dereference (a class name followed by a
* {@code COLON} that has no following whitespace.
*
* @param la1
* The lookahead 1 token to test.
* @param la2
* The lookahead 2 token to test.
*
* @return {@code true} if the tokens could be a static class dereference.
*/
private boolean isClassDereference(Token la1, Token la2)
{
return la2.getType() == COLON && !followedByWhitespace(la2) && sym.canLoadClass(la1.getText());
}
/**
* Determine if the token is valid as the leftmost token in an expression. If this is a reserved keyword
* it is checked to see if it is valid as the leftmost keyword OR if it is a valid class name. If the
* token is not a reserved keyword, then it is assumed valid.
* <p>
* Only a small number of reserved keywords are allowed in the leftmost token of an expression except
* for class names. The problem is that allowing all reserved keywords to "pull" into the assignment
* rule will break parsing badly (except for the leftmost static references to class names that are also
* reserved keywords). This method provides a means to detect only those cases that are valid.
*
* @param la1
* The lookahead 1 token to test.
* @param la2
* The lookahead 2 token to test.
*
* @return {@code true} if the token should be allowed as the leftmost token in an expression.
*/
private boolean isValidLeftmostReserved(Token la1, Token la2)
{
int type = la1.getType();
boolean valid = (type == KW_U_CTRL || type == KW_U_MSG || type == KW_U_PCTRL ||
type == KW_U_SERIAL || type == KW_ACCUM || type == KW_ASC ||
type == KW_ACT_FORM || type == KW_ACT_WIN || type == KW_ALIAS ||
type == KW_AMBIG || type == KW_AUD_CTRL || type == KW_AUD_POL ||
type == KW_AVAIL || type == KW_B_ENDIAN || type == KW_CAN_DO ||
type == KW_CAN_FIND || type == KW_CAST || type == KW_CHR ||
type == KW_CLIP || type == KW_CODEBASE || type == KW_COMPILER ||
type == KW_CONN_ED || type == KW_COUNT_OF || type == KW_CUR_CHG ||
type == KW_CUR_LANG || type == KW_CUR_WIN || type == KW_DATA_SRC ||
type == KW_DATASRV || type == KW_DATASET || type == KW_DBCP ||
type == KW_DBCOLL || type == KW_DBNAME || type == KW_DBPARAM ||
type == KW_DBREST || type == KW_DBTASKID || type == KW_DBTYPE ||
type == KW_DBVERS || type == KW_DEBUGGER || type == KW_DEF_WIN ||
type == KW_DLL_C_T || type == KW_DSET_HND || type == KW_DYN_ENUM ||
type == KW_DYN_FUNC || type == KW_DYN_INVK || type == KW_DYN_NEW ||
type == KW_DYN_PROP || type == KW_ENCODE || type == KW_ENTRY ||
type == KW_ERR_STAT || type == KW_EXC_LOCK || type == KW_ETIME ||
type == KW_FIL_INFO || type == KW_FILL || type == KW_FIND_CS ||
type == KW_FIND_GLO || type == KW_FIND_NO || type == KW_FIND_PO ||
type == KW_FIND_SEL || type == KW_FIND_WA || type == KW_FIRST ||
type == KW_FIRST_OF || type == KW_FOCUS || type == KW_FRAME ||
type == KW_FR_COL || type == KW_FR_DB || type == KW_FR_DOWN ||
type == KW_FR_FIELD || type == KW_FR_FILE || type == KW_FR_INDEX ||
type == KW_FR_LINE || type == KW_FR_NAME || type == KW_FR_ROW ||
type == KW_FR_VAL || type == KW_FUNC_C_T || type == KW_GW ||
type == KW_GET_A_CT || type == KW_GET_BYTE || type == KW_GET_CODP ||
type == KW_GET_COLL || type == KW_GO_PEND || type == KW_HOST_B_O ||
type == KW_HASHCODE || type == KW_IF || type == KW_INDEX ||
type == KW_INPUT || type == KW_IS_ATTR || type == KW_IS_LEAD ||
type == KW_KBLABEL || type == KW_KEYCODE || type == KW_KEYFUNC ||
type == KW_KEYLAB || type == KW_KW || type == KW_L_ENDIAN ||
type == KW_LAST || type == KW_LASTKEY || type == KW_LAST_EVT ||
type == KW_LAST_OF || type == KW_LDBNAME || type == KW_LIB ||
type == KW_LINE_CNT || type == KW_LOCKED || type == KW_LOG_MGR ||
type == KW_LOOKUP || type == KW_MEMBER || type == KW_MSG_LINE ||
type == KW_NEW || type == KW_NO_LOCK || type == KW_NO_RET_V ||
type == KW_NO_WAIT || type == KW_NOT || type == KW_NOW ||
type == KW_NUM_ALIA || type == KW_NUM_DBS || type == KW_NUM_ENT ||
type == KW_OPSYS || type == KW_OVERLAY || type == KW_PAGE_NUM ||
type == KW_PDBNAME || type == KW_PROC_C_T || type == KW_PROC_HND ||
type == KW_PROC_ST || type == KW_PROFILER || type == KW_PROGNAME ||
type == KW_PROGRESS || type == KW_PROMSGS || type == KW_PROPATH ||
type == KW_PROVER || type == KW_PUT_BYTE || type == KW_QUERY ||
type == KW_QRY_OFF || type == KW_R_INDEX || type == KW_RCOD_INF ||
type == KW_READ_AVL || type == KW_READ_E_N || type == KW_RECID ||
type == KW_RETRY || type == KW_ROW_CRTD || type == KW_ROW_DELD ||
type == KW_ROW_MODD || type == KW_ROW_UMOD || type == KW_RTOPSYS ||
type == KW_SAX_COMP || type == KW_SAX_PARE || type == KW_SAX_RUNN ||
type == KW_SAX_UNIN || type == KW_SAX_WBEG || type == KW_SAX_WCOM ||
type == KW_SAX_WCON || type == KW_SAX_WELM || type == KW_SAX_WERR ||
type == KW_SAX_WIDL || type == KW_SAX_WTAG || type == KW_SCRN_LNS ||
type == KW_SDBNAME || type == KW_SEAR_SLF || type == KW_SEAR_TRG ||
type == KW_SEARCH || type == KW_SECUR_P || type == KW_SEEK ||
type == KW_SELF || type == KW_SESSION || type == KW_SET_A_CT ||
type == KW_SETUSER || type == KW_SH_LOCK || type == KW_STREAM ||
type == KW_STRM_HND || type == KW_SUPER || type == KW_TABLE ||
type == KW_TERM || type == KW_THIS_OBJ || type == KW_THIS_PRC ||
type == KW_TIME || type == KW_TO_ROWID || type == KW_TRANS ||
type == KW_TRIM || type == KW_USERID || type == KW_WIN_DMIN ||
type == KW_WIN_MAX || type == KW_WIN_MIN || type == KW_WIN_NORM ||
type == KW_FWD_DRIV || type == KW_DSL_MGR);
return !(type > BEGIN_RESERVED && type < END_RESERVED) || valid || isClassDereference(la1, la2);
}
/**
* Determine if the specified type belongs to a binary operator.
*
* @param type
* The parameter to check.
*
* @return <code>true</code> if the type belongs to a binary operator.
*/
private boolean isBinaryOp(long type)
{
return type == KW_OR || type == KW_AND ||
type == KW_NOT || type == KW_EQ ||
type == NOT_EQ || type == KW_NE ||
type == GT || type == KW_GT ||
type == LT || type == KW_LT ||
type == GTE || type == KW_GTE ||
type == LTE || type == KW_LTE ||
type == KW_BEGINS || type == KW_MATCHES ||
type == KW_CONTAINS || type == PLUS ||
type == MINUS || type == MULTIPLY ||
type == DIVIDE || type == KW_MOD;
}
/**
* Determine if the passed reference can act as a l-value in an assignment.
*
* @param ref
* The AST to check if is a possible l-value.
*
* @return <code>true</code> if the passed AST can act as an l-value.
*/
private boolean isLvalue(Aast ref)
throws TokenStreamException
{
long type = ref.getType();
if (type >= BEGIN_LVALUE && type <= END_LVALUE)
{
return true;
}
if (type == DB_REF_NON_STATIC)
{
return true;
}
if (type == COM_INVOCATION)
{
Aast ref2 = ref.getChildAt(1);
type = ref2.getType();
// indexed properties are disguised as COM_METHOD by the lexer
return type == COM_PROPERTY || (type == COM_METHOD && LA(1) == EQUALS);
}
if (type == OBJECT_INVOCATION)
{
Aast ref2 = ref.getChildAt(1);
return isLvalue(ref2);
}
if (type == COLON)
{
Aast ref2 = ref.getChildAt(1);
type = ref2.getType();
return (type >= BEGIN_ATTR && type <= END_ATTR);
}
if (isLstmt(type))
{
return true;
}
if (type >= BEGIN_FUNCTYPES && type <= END_FUNCTYPES)
{
type = (long) ref.getAnnotation("oldtype");
return isLstmt(type);
}
return false;
}
/**
* Scan forward to determine if the current node is an inline variable
* definition. For this to be the case, the current node must be a
* symbol which is not already a variable or field. In addition, it must
* be followed by an <code>AS</code> or <code>LIKE</code> keyword.
* <p>
* <b>At this time, this method will not work 100% properly so DON'T use
* it! WARNING: this code needs to know when to stop looking ahead and
* this test is far too permissive! We really need to stop when the format
* phrase is done. But to predict when that might occur is not easy!</b>
*
* @return <code>true</code> if this is an inline variable definition.
*/
private boolean isFormVarDefinition()
throws TokenStreamException
{
Token candidate = LT(1);
int typ = candidate.getType();
String txt = candidate.getText();
if (typ == SYMBOL || (typ > BEGIN_UNRESERVED && typ < END_UNRESERVED))
{
if (sym.lookupVariable(txt) == -1 && !sym.isField(txt))
{
int idx = 2;
while (true)
{
int next = LA(idx);
// WARNING: this code needs to know when to stop looking ahead
// and this test is far too permissive! We really
// need to stop when the format phrase is done. But
// to predict when that might occur is not easy!
if (next == KW_WITH || next == DOT)
{
break;
}
if (next == KW_AS || next == KW_LIKE)
{
return true;
}
idx++;
}
}
}
return false;
}
/**
* Check the tokens starting at the given index to see if they match a malformed label (that
* starts with a reserved keyword), a colon and then is followed by the beginning of an inner
* block. If found, rewrite the leading reserved keyword's token type to a SYMBOL so that
* the prediction logic for a downstream <code>single_block</code> will be engaged. This
* should only ever be called just before a <code>single_block</code> is entered.
*
* @param idx
* The index of the token that would start the label (and it would be a reserved
* keyword).
*/
private void checkAndFixLabelWithReservedKeywordPrefix(int idx)
throws TokenStreamException,
MismatchedTokenException
{
int rtype = LA(idx);
if (rtype > BEGIN_RESERVED && rtype < END_RESERVED)
{
Predicate<CommonToken> follow = (CommonToken tok) ->
{
int type = tok.getType();
return (type == KW_DO || type == KW_REPEAT || type == KW_FOR || type == KW_EDITING);
};
if (isMalformedLabel(true, idx, follow))
{
LT(idx).setType(SYMBOL);
}
}
}
/**
* Manually looks ahead an 2 tokens to determine if the next tokens represent a properly
* formed symbol. Normal symbols must start with an alphabetic character or an underscore.
* They must then be followed by a colon and then whitespace. The problem is that it is
* legal to use nearly all unreserved keywords as labels. This method matches these cases
* except for the one case that is unreserved but is still excluded from being a label
* (the FINALLY keyword).
* <p>
* A malformed label will NOT be matched by this rule (see {@link #isMalformedLabel}).
*
* @param typ
* The token type of the first lookahead token. This is a performance optimization
* only since the same value could have been queried too.
*
* @return <code>true</code> if the following tokens represent a match as a properly
* formed label.
*/
private boolean isProperLabel(int typ)
throws TokenStreamException
{
// must be a valid symbol or unreserved keyword (except finally is unreserved
// but cannot be used as a label!)
if (typ == SYMBOL || ((typ > BEGIN_UNRESERVED && typ < END_UNRESERVED) &&
typ != KW_FINALLY))
{
// possible label
if (LA(2) == COLON && followedByWhitespace(LT(2)))
{
// OK, this is a properly formed label
return true;
}
}
return false;
}
/**
* Manually looks ahead an arbitrary number of tokens to determine if the next tokens
* represent a malformed symbol. Normal symbols must start with an alphabetic character
* or an underscore. Labels have been found to possibly start with a pretty much any kind
* of text including @#$%^, hyphens, operators and other "second and later" symbol
* characters. The lexer cannot know when to lex a symbol in such a manner so it must be
* detected and put back together in the parser. This method detects the malformed label
* case.
* <p>
* A normal label will NOT be matched by this rule so any testing for normal labels must be
* done outside of this rule. See {@link #isProperLabel}.
*
* @param def
* <code>true</code> if this should test for a label definition (the malformed
* symbol must be followed by a colon). When <code>false</code>, no colon is
* expected BUT the resulting text must appear in the scoped label dictionary.
* @param start
* The index of the token at which to start checking.
* @param follow
* If non-null AND a malformed label has been detected, this predicate will be
* checked against the AST node that immediately follows the COLON. This is only
* checked in label definition mode.
*
* @return <code>true</code> if the following tokens represent a match as a malformed
* label.
*/
private boolean isMalformedLabel(boolean def, int start, Predicate<CommonToken> follow)
throws TokenStreamException,
MismatchedTokenException
{
int[] end = new int[] { COLON, COMMA, LPARENS, RPARENS, EOF };
int num = start;
CommonToken current = (CommonToken) LT(num);
CommonToken next = (CommonToken) LT(++num);
int nextType = next.getType();
StringBuilder sb = new StringBuilder();
while (!followedByWhitespace(current) &&
!matchesList(nextType, end) &&
!(nextType == DOT && followedByWhitespace(next)))
{
// save the text of the current token
if (!def)
sb.append(current.getText());
// update the state for next iteration
current = next;
next = (CommonToken) LT(++num);
nextType = next.getType();
}
// did more than 1 token get processed?
if (num > (start + 1))
{
if (!def)
{
// put the last text into the buffer
sb.append(current.getText());
// possible label reference
if (sym.lookupLabel(sb.toString()) != -1)
{
return true;
}
}
else
{
// possible new label definition
// we have a candidate label (text that could be a label) but it
// must be followed by a COLON and whitespace to fully match
if (next.getType() == COLON && followedByWhitespace(next))
{
if (follow != null)
{
return follow.test((CommonToken) LT(num + 1));
}
return true;
}
}
}
return false;
}
/**
* The P4GL requires an additional space after keyword operators. This method checks if this
* exists and if it is missing a parsing exception is thrown. Note that the space is not
* required BEFORE the keyword operator and not required at either ends in case of symbol
* operator.
* <p>
* Known affected keyword operators are: {@code kw_eq}, {@code kw_ne}, {@code kw_lt},
* {@code kw_gt}, {@code kw_gte}, {@code kw_lte}, {@code kw_matches}, {@code kw_begins},
* {@code kw_contains}, {@code kw_or} and {@code kw_and}.
*
* @param binOperator
* Aast node of the operator to be checked.
*
* @param allowUnknown
* Flag indicating if unknown value can be on right without any whitespace.
*
* @throws MismatchedTokenException
* if no space is encounter after this token.
* @throws MismatchedTokenException
* if fails to extract the next token.
*/
private void checkExtraSpace(Aast binOperator, boolean allowUnknown)
throws MismatchedTokenException,
TokenStreamException
{
if (followedByWhitespace(LT(0)) || (allowUnknown && LA(1) == UNKNOWN_VAL))
{
// this is how P4GL expects
return;
}
// second chance: if the second operand is parenthesized the P4GL validates it
if (LT(1).getType() == LPARENS)
{
return;
}
MismatchedTokenException exc =
new MismatchedTokenException(new String[] { "Unknown Field or Variable name" },
binOperator, -1, -1, true);
exc.token = LT(0);
throw exc;
}
/**
* Manually looks ahead an arbitrary number of tokens to determine if the
* next tokens represent a malformed symbol as a function name followed by
* an <code>LPARENS</code>. Normal function names must start
* with an alphabetic character or an underscore. Other names have been
* found which can possibly start with a number, hyphen and other
* "second and later" symbol characters. The lexer cannot know when to
* lex a symbol in such a manner so it must be detected and put back
* together in the parser.
* <p>
* This does not match any tokens, it just reads ahead to check.
*
* @return <code>true</code> if and only if the following tokens represent
* a match as a malformed function call name.
*/
private boolean isMalformedSymbolFuncCall()
throws TokenStreamException
{
int idx = 1;
Token next = LT(1);
int ttype = next.getType();
StringBuilder sb = new StringBuilder();
// a malformed symbol must start with one of these tokens
if (ttype != NUM_LITERAL &&
ttype != HEX_LITERAL &&
ttype != DATE_LITERAL &&
ttype != DATETIME_LITERAL &&
ttype != DATETIME_TZ_LITERAL &&
ttype != MINUS &&
ttype != UNKNOWN_TOKEN)
{
return false;
}
while (true)
{
// any intervening whitespace before we hit text means this is not a
// match
if (followedByWhitespace(next))
{
break;
}
// store the text of the current token
sb.append(next.getText());
// get the next token (which we already know is contiguous)
idx++;
next = LT(idx);
ttype = next.getType();
// when the next token falls in this range, it means there is some
// alphabetic text following the other trash (this will cause the
// symbol rule to be matched in the lexer, which can produce one of
// these types), which tells us that this is a valid symbol
if ((ttype > BEGIN_RESERVED && ttype < END_RESERVED) ||
(ttype > BEGIN_UNRESERVED && ttype < END_UNRESERVED) ||
ttype == SYMBOL)
{
// this should be the last bit of the function name
sb.append(next.getText());
// this is a malformed symbol, BUT is it a function call?
idx++;
next = LT(idx);
boolean func = (next.getType() == LPARENS) &&
(sym.lookupFunction(sb.toString()) != -1);
// if this is followed by an LPARENS (regardless of whitespace in
// between) and the name can be looked up in our function dictionary
// then this is a function call
return func ? true : false;
}
// iterate as long as there is valid preceding crap to read through
if (ttype == NUM_LITERAL ||
ttype == HEX_LITERAL ||
ttype == DATE_LITERAL ||
ttype == DATETIME_LITERAL ||
ttype == DATETIME_TZ_LITERAL ||
ttype == MINUS ||
ttype == UNKNOWN_TOKEN)
{
continue;
}
// we must not have matched anything valid, this isn't a malformed
// symbol
break;
}
return false;
}
/**
* Detect if the given token type is a symbol or unreserved keyword.
*
* @param ttype
* The token type to check;
*
* @return <code>true</code> if the type is some kind of symbol.
*/
private boolean isSomeSymbol(int ttype)
{
return (ttype == SYMBOL || (ttype > BEGIN_UNRESERVED && ttype < END_UNRESERVED));
}
/**
* Manually looks ahead an arbitrary number of tokens to determine if the
* next tokens represent a malformed symbol. Normal symbols must start
* with an alphabetic character or an underscore. Other names have been
* found which can possibly start with a number, hyphen and other
* "second and later" symbol characters. The lexer cannot know when to
* lex a symbol in such a manner so it must be detected and put back
* together in the parser.
* <p>
* This does not match any tokens, it just reads ahead to check.
*
* @param start
* Starting token to check.
*
* @return <code>true</code> if and only if the following tokens represent
* a match as a malformed symbol.
*/
private boolean isMalformedSymbol(int start)
throws TokenStreamException
{
int idx = start;
Token next = LT(idx);
int ttype = next.getType();
// a malformed symbol must start with one of these tokens
if (ttype != NUM_LITERAL &&
ttype != HEX_LITERAL &&
ttype != DATE_LITERAL &&
ttype != DATETIME_LITERAL &&
ttype != DATETIME_TZ_LITERAL &&
ttype != MINUS &&
ttype != UNKNOWN_TOKEN)
{
return false;
}
while (true)
{
// any intervening whitespace before we hit text means this is not a
// match
if (followedByWhitespace(next))
{
break;
}
// get the next token (which we already know is contiguous)
idx++;
next = LT(idx);
ttype = next.getType();
// when the next token falls in this range, it means there is some
// alphabetic text following the other trash (this will cause the
// symbol rule to be matched in the lexer, which can produce one of
// these types), which tells us that this is a valid symbol
if ((ttype > BEGIN_RESERVED && ttype < END_RESERVED) ||
(ttype > BEGIN_UNRESERVED && ttype < END_UNRESERVED) ||
ttype == SYMBOL)
{
// this is a malformed symbol
return true;
}
// iterate as long as there is valid preceding crap to read through
if (ttype == NUM_LITERAL ||
ttype == HEX_LITERAL ||
ttype == DATE_LITERAL ||
ttype == DATETIME_LITERAL ||
ttype == DATETIME_TZ_LITERAL ||
ttype == MINUS ||
ttype == UNKNOWN_TOKEN)
{
continue;
}
// we must not have matched anything valid, this isn't a malformed
// symbol
break;
}
return false;
}
/**
* Manually looks ahead an arbitrary number of tokens, reassembling the text
* and type of a malformed symbol into a single token while dropping the
* extraneous tokens.
* <p>
* This discards bogus intermedite tokens and fixes up the last token in the
* stream. You MUST already know that the following tokens ARE a malformed
* symbol by using {@link #isMalformedSymbolFuncCall}!
*
* @return The text of the token that was reassembled.
*/
private String reassembleMalformedSymbol()
throws TokenStreamException,
NoViableAltException,
MismatchedTokenException
{
ManagedHiddenStreamToken next = (ManagedHiddenStreamToken) LT(1);
int ttype = next.getType();
// a malformed symbol must start with one of these tokens
if (ttype != NUM_LITERAL &&
ttype != HEX_LITERAL &&
ttype != DATE_LITERAL &&
ttype != DATETIME_LITERAL &&
ttype != DATETIME_TZ_LITERAL &&
ttype != MINUS &&
ttype != UNKNOWN_TOKEN)
{
throw new NoViableAltException(LT(1), getFilename());
}
while (true)
{
// any intervening whitespace before we hit text means this is not a
// match
if (followedByWhitespace(next))
{
throw new NoViableAltException(LT(1), getFilename());
}
next.merge();
// this is a token we are discarding, match it
match(ttype);
// get the next token
next = (ManagedHiddenStreamToken) LT(1);
ttype = next.getType();
// when the next token falls in this range, it means there is some
// alphabetic text following the other trash (this will cause the
// symbol rule to be matched in the lexer, which can produce one of
// these types), which tells us that this is a valid symbol
if ((ttype > BEGIN_RESERVED && ttype < END_RESERVED) ||
(ttype > BEGIN_UNRESERVED && ttype < END_UNRESERVED) ||
ttype == SYMBOL)
{
break;
}
// iterate as long as there is valid preceding crap to read through
if (ttype != NUM_LITERAL &&
ttype != HEX_LITERAL &&
ttype != DATE_LITERAL &&
ttype != DATETIME_LITERAL &&
ttype != DATETIME_TZ_LITERAL &&
ttype != MINUS &&
ttype != UNKNOWN_TOKEN)
{
throw new NoViableAltException(LT(1), getFilename());
}
}
return next.getText();
}
/**
* Detect is the next token type is a reserved keyword that can appear in an inner block (DO, REPEAT or
* FOR) header or in/following a query's record phrase. This is used to detect when the next token is
* not a valid expression but is rather a reserved keyword that should be avoided.
*
* @param sql
* Flag indicating if this is matching from a SQL statement.
*
* @return {@code true} if the next token is a reserved keyword that can appear in an inner block
* header or in/after a record phrase.
*/
private boolean isValidBlockHeaderOrQueryKeyword(boolean sql)
throws TokenStreamException
{
int type = LA(1);
// these tokens are reserved only for SQL, 4GL WHERE allows fields with such names
return (sql &&
(type == KW_LEFT || type == KW_ORDER || type == KW_OUT_JOIN || type == KW_RIGHT ||
type == KW_TAB_SCAN || type == KW_COLLATE || type == KW_IDX_REPO || type == KW_MAX_ROWS)) ||
type == KW_GROUP || type == KW_HAVING || type == KW_NO_PRE || type == KW_NO_ERROR ||
type == KW_SH_LOCK || type == KW_EXC_LOCK || type == KW_NO_LOCK || type == KW_NO_WAIT ||
type == KW_OF || type == KW_USE_IDX || type == KW_USING || type == KW_WHERE ||
type == KW_WHILE || type == KW_TRANS || type == KW_STOP_AFT || type == KW_ON ||
type == KW_QRY_TUNE || type == KW_BREAK || type == KW_BY || type == KW_WITH;
}
/**
* Core lookahead processing for the lvalue rule which checks for a match to a variable,
* widget, class data member/property or database field. It will NOT match qualifiers
* frames, streams or assignment style statements. This is useful for detecting if a
* following token stream is an lvalue or not. When token stream changes are allowed,
* the text can be rewritten and tokens can even be matched. DO NOT allow changes when
* passing an index other than 1, as any matching done will not match on the tokens
* expected.
* <p>
* This is split off from the lvalue rule itself so that other code can call this for
* lookahead purposes (no changes allowed).
*
* @param idx
* The token at which to start looking for an lvalue match. This is a 1-based
* index which is how ANTLR works.
* @param allowChange
* <code>true</code> to enable token text modification and matching. This only
* occurs with certain validation and field naming quirks.
*
* @return The token type if the tokens are an lvalue or -1 if no match was found.
*/
private int resolveLvalueCoreType(int idx, boolean allowChange)
throws TokenStreamException,
MismatchedTokenException
{
String text = LT(idx).getText();
// variables by the same name as a field, will hide that field
int newtype = sym.lookupVariable(text);
// there are some cases where calling rules (possibly far up
// the call stack) need to match a widget in preference to
// a variable, in these cases a global state variable is
// set and this will override any variable found with a
// widget instead (if the widget exists)
if (preferWidgets)
{
int widtype = sym.lookupWidget(text);
if (widtype != -1)
newtype = widtype;
}
else
{
// in normal processing, we might not prefer widgets but we
// still need to check for a match
if (newtype == -1)
{
// this must be a widget name
newtype = sym.lookupWidget(text);
}
}
int idx2 = idx + 1;
int idx3 = idx + 2;
boolean isFieldQuirk = isQualifiedFieldNameQuirk(LT(idx), LT(idx2), LT(idx3));
// check if this is an object data member or property (may be defined somewhere in the
// class hierarchy); calling rules may set the class name based on context to control the
// lookup here
if (newtype == -1 && !isFieldQuirk)
{
newtype = sym.lookupDataMember(currentClassName, text, currentStaticFlag);
}
// special processing for validation (if there is a match to the short name only, we
// override with the full schema name to make it unambiguous)
if (newtype == -1 && validation && validateFieldName != null)
{
int sidx = validateFieldName.lastIndexOf('.');
String ambig = validateFieldName.substring(sidx + 1).toLowerCase();
String lcText = text.toLowerCase();
// test in ignore-case and also handle abbreviations
if (ambig.startsWith(lcText))
{
text = validateFieldName;
// force the text to the full name
if (allowChange)
{
LT(idx).setText(validateFieldName);
}
}
}
// handle a qualified database naming quirk in which there
// is whitespace between the record and the DOT and/or
// whitespace between the DOT and the field portion such that
// Progress matches "record .field" or "record. field" or
// "record . field" all as the single qualified field name
// "record.field";
if (newtype == -1 && isFieldQuirk)
{
StringBuilder sb = new StringBuilder();
sb.append(text).append('.').append(LT(idx3).getText());
String total = sb.toString();
newtype = sym.lookupField(currentRecord, total);
if (newtype != -1 && allowChange)
{
// we have the special case of a whitespace-infested
// qualified database name, put it "back together"
StringBuilder orig = new StringBuilder();
// merge LA(idx) into LA(idx2)
ManagedHiddenStreamToken tok = (ManagedHiddenStreamToken) LT(idx);
// save the text of all 3 tokens
orig.append(tok.getText());
String middle = LT(idx2).getText();
String last = LT(idx3).getText();
// merge the first and second tokens
String ws = tok.merge();
// save off any hidden text in between
if (ws != null)
{
orig.append(ws);
}
// add the middle token's text to the buffer
orig.append(middle);
// manually match the old token to remove it from the stream
match(LA(idx));
// LT(idx) is the same token that previously was LA(idx2)
tok = (ManagedHiddenStreamToken) LT(idx);
// merge LA(idx2) into LA(idx3)
ws = tok.merge();
// save off any hidden text in between
if (ws != null)
{
orig.append(ws);
}
// add the third token's text to the buffer
orig.append(last);
// manually the LA(idx2) token to remove it from the stream
match(DOT);
// save the original text
fieldNameQuirkOriginalText = orig.toString();
}
}
// lookup a field if the variable/widget reference wasn't found the call to isField()
// is needed because otherwise the schema dictionary may report an ambiguous name even
// though we don't care about such reports; this is done before the name quirk processing
// so that a simple field reference is honored in preference
if ((preferFields || newtype == -1) && sym.isField(text))
{
// this may be a field name
newtype = sym.lookupField(currentRecord, text);
}
return newtype;
}
/**
* Common code to add a scope (symbol dictionary and schema scopes) for a
* trigger. See <code>clearTriggerScope()</code>.
* <p>
* Triggers can be nested inside procedures, functions and other triggers
* so we must save the value found here so that it can be restored later.
* Otherwise we would force everything else to global scope while still in
* a nested scope.
*
* @return The previous state of the <code>bufferScope</code> variable
* which will be set to <code>false</code> by this method and
* which must be reset to this returned value when the scope
* is popped.
*/
private boolean setupTriggerScope()
{
boolean oldBufScope = bufferScope;
sym.addScope();
sym.addSchemaScope(true);
bufferScope = false;
return oldBufScope;
}
/**
* Common code to remove a scope (symbol dictionary and schema scopes) for
* a trigger. See <code>setupTriggerScope()</code>.
* <p>
* Triggers can be nested inside procedures, functions and other triggers
* so we must restore the value found at entry so that we don't force
* everything else to global scope while still in a nested scope.
*
* @param oldBufScope
* The previous state of the <code>bufferScope</code> flag
* which will be restored in this call.
*/
private void clearTriggerScope(boolean oldBufScope)
{
bufferScope = oldBufScope;
// triggers propagate
sym.deleteSchemaScope(true);
sym.deleteScope();
}
/**
* Defines a new buffer for the given record name based on the given symbol node which
* specifies the buffer name. The resulting symbol node is annotated as a result and the
* symbol resolver and schema dictionary are updated as needed to be aware of the new buffer.
*
* @param symbol
* The node that defines the buffer's name.
* @param recordName
* The record that defines the buffer's structure.
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param forceTemp
* if {@code true}, assume {@code recordName} represents a temp-table, and do not
* search for it in the global schema scope when adding fields from it to the buffer
* being define.
*
* @return <code>true</code> if the buffer was properly built.
*/
private boolean defineBufferFromSymbol(Aast symbol,
String recordName,
Aast am,
Aast st,
boolean forceTemp)
{
return defineBufferFromSymbol(symbol, recordName, am, st, forceTemp, true);
}
/**
* Defines a new buffer for the given record name based on the given symbol node which
* specifies the buffer name. The resulting symbol node is annotated as a result and the
* symbol resolver and schema dictionary are updated as needed to be aware of the new buffer.
*
* @param symbol
* The node that defines the buffer's name.
* @param recordName
* The record that defines the buffer's structure.
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param forceTemp
* if {@code true}, assume {@code recordName} represents a temp-table, and do not
* search for it in the global schema scope when adding fields from it to the buffer
* being define.
* @param fail
* Flag indicating if an exception should be thrown if a match is not found.
*
* @return <code>true</code> if the bufffer was properly built.
*/
private boolean defineBufferFromSymbol(Aast symbol,
String recordName,
Aast am,
Aast st,
boolean forceTemp,
boolean fail)
{
String name = symbol.getText();
if (SymbolResolver.isPreScan() && name.equalsIgnoreCase(recordName))
{
// in pre-scan mode, leave only the 'default' buffer and do not allow override with the same name.
// this 'DEFINE BUFFER b1 FOR b1' statement is possible only for temp-table buffers; for permanent
// buffers, you can't redefine an already defined 'b1' buffer.
return true;
}
// the target scope is determined by whether we are currently
// executing in an internal procedure, function or trigger in which
// case bufferScope is false, otherwise it is true and the
// buffer is created in a global scope
Object table = sym.addTable(name, BUFFER, bufferScope, symbol, am, st);
Aast[] fields = sym.addFieldsFrom(table, recordName, forceTemp, false, fail);
if (fields != null)
{
String bufname = sym.lookupBufferName(name, false);
symbol.putAnnotation("bufname", bufname);
}
return fields != null;
}
/**
* If the next token is DOT, COLON, RPARENS, EQUALS, RBRACE, LBRACKET, RBRACKET, PIPE, COMMA,
* LT, GT or NOT_EQ then attempt to merge until WS is hit with an exclusion of DOT, KW_VALUE
* and KW_NO_ERROR. If merging happens, then the resulting token will be BROKEN_PREPROC_ARG.
* This behavior matches the possible broken_preproc_args cases.
* <p>
* The only exception is LPARENS which is valid for this case in the 4GL, but which cannot
* be disambiguated from the use of LPARENS in a real expression (which also works).
*/
private void fixupBrokenPreprocArg()
throws TokenStreamException,
MismatchedTokenException
{
boolean rbraceOrPipe = false;
// there is no separate token type or RBRACE or PIPE
if (LA(1) == UNKNOWN_TOKEN)
{
CommonToken tok = (CommonToken) LT(1);
String txt = tok.getText();
rbraceOrPipe = ("}".equals(txt) || "|".equals(txt));
}
// Include check for *next* token being EOF, so we don't process farther than necessary
boolean notDot = (LA(1) == DOT && !followedByWhitespace(LT(1)) && (LA(2) != EOF));
// TODO: LPARENS should be in this list but we don't have an easy way to disambiguate it
// from a following expr
// NOT_EQ is a possible leading combo instead of LT
if (notDot || LA(1) == COLON || LA(1) == RPARENS || LA(1) == EQUALS ||
LA(1) == LBRACKET || LA(1) == RBRACKET || LA(1) == COMMA || LA(1) == LT ||
LA(1) == GT || LA(1) == NOT_EQ || rbraceOrPipe)
{
// DOT and EOF are hard coded in the worker routine
int[] exclargs = new int[]
{
KW_VALUE,
KW_NO_ERROR
};
mergeUntilWS(exclargs);
// even if the first token was not merged, it must be random junk so we have
// to force the type to something that won't predict the expr rule
LT(1).setType(BROKEN_PREPROC_ARG);
}
}
/**
* Merge the following non-hidden token text until (and including) a token followed by
* whitespace or one of a list of following tokens that cannot be matched. There are 2
* special tokens added to the list which is passed as a parameter: <code>DOT</code> and
* <code>EOF</code>. The <code>DOT</code> is special, in that it is allowed to continue the
* merging IF it is NOT followed by whitespace. IF the <code>DOT</code> is followed by
* whitespace then the merging process ends and the <code>DOT</code> is NOT included
* in the merged text.
* <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.
*
* @param end
* List of token types which trigger end of merging (in addition to <code>DOT</code>
* and <code>EOF</code>). May be <code>null</code> if there are no additional token
* types.
*
* @return <code>true</code> if merging was done, <code>false</code> if no changes were
* made.
*/
private boolean mergeUntilWS(int[] end)
throws TokenStreamException,
MismatchedTokenException
{
if (end == null)
{
end = new int[1];
}
else
{
int[] list = new int[end.length + 1];
for (int i = 0; i < end.length; i++)
{
list[i + 1] = end[i];
}
end = list;
}
end[0] = EOF;
int first = LA(1);
// quick exit if the first token is in the exit list
for (int i = 0; i < end.length; i++)
{
if (end[i] == first)
{
return false;
}
}
boolean merged = false;
ManagedHiddenStreamToken current = (ManagedHiddenStreamToken) LT(1);
ManagedHiddenStreamToken next = (ManagedHiddenStreamToken) LT(2);
ManagedHiddenStreamToken after = (ManagedHiddenStreamToken) LT(3);
int type = next.getType();
while (!followedByWhitespace(current) &&
!matchesList(type, end) &&
!(type == DOT &&
(followedByWhitespace(next) || (after != null && after.getType() == EOF))))
{
merged = true;
// merge into the next non-hidden token, the current token still exists but the token
// stream is patched so that the current token can be dropped without any loss of data
current.merge();
// match the current token but leave the next token unmatched
if (current.getType() == DOT)
{
match(DOT);
}
else
{
matchNot(DOT);
}
// update the state for next iteration
current = next;
next = after;
after = (ManagedHiddenStreamToken) LT(3);
type = next.getType();
}
return merged;
}
/**
* Check if the next token has text of "alt-", "ctrl-", "esc-" or "shift-" and if so, merge
* that token with all others until whitespace (or some exclusion characters like COMMA) are
* encountered. This is a special parsing mode enabled by the 4GL for event matching. No
* changes are made if there is no match.
*/
private void fixupKeyboardModifiers()
throws TokenStreamException,
MismatchedTokenException
{
// DOT and EOF are hard coded in the worker routine
int[] exclude = new int[]
{
COLON,
COMMA,
EQUALS,
LPARENS,
RPARENS,
NOT_EQ,
LT,
LTE,
GT,
GTE
};
String ttxt = LT(1).getText();
// special parsing rules for these keyboard modifiers where they can be paired with
// a hyphen and any other "key text" without being escaped in a string literal; for
// example alt-+, shift-a, ctrl-down, esc-5; the problem is that the normal prediction
// logic won't work since there are multiple tokens; only these prefixes work this
// way!
if (ttxt.equalsIgnoreCase("alt-") || ttxt.equalsIgnoreCase("ctrl-") ||
ttxt.equalsIgnoreCase("esc-") || ttxt.equalsIgnoreCase("shift-"))
{
// parse until whitespace
mergeUntilWS(exclude);
LT(1).setType(SYMBOL);
}
}
/**
* Tests if the given <code>type</code> matches any in the given list.
*
* @param type
* The token type to test for.
* @param list
* The list to check against.
*
* @return <code>true</code> if the given type is in the list.
*/
private boolean matchesList(int type, int[] list)
{
for (int i = 0; i < list.length; i++)
{
if (type == list[i])
return true;
}
return false;
}
/**
* 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)
{
ManagedHiddenStreamToken space = null;
space = (ManagedHiddenStreamToken) hidden.getHiddenAfter((ManagedHiddenStreamToken) tok);
return (space != null && space.getType() == WS);
}
/**
* Check all following hidden tokens to see if there is by whitespace in the original
* source code which includes a newline character.
*
* @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 the last content on the line.
*/
private boolean followedByLineEnd(Token tok)
{
ManagedHiddenStreamToken hid = (ManagedHiddenStreamToken) tok;
hid = (ManagedHiddenStreamToken) hid.getHiddenAfter();
while (hid != null)
{
if (hid.getType() == WS && hid.getText().indexOf("\n") != -1)
{
return true;
}
hid = (ManagedHiddenStreamToken) hid.getHiddenAfter();
}
return false;
}
/**
* 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)
{
ManagedHiddenStreamToken space = null;
space = (ManagedHiddenStreamToken) hidden.getHiddenBefore((ManagedHiddenStreamToken) tok);
return (space != null && space.getType() == WS);
}
/**
* Helper function to convert a <code>STRING</code> node into a node of the specified type.
*
* @param node
* The <code>STRING</code> node to modify.
* @param newtype
* The new type of the target node. If passed as -1, the type will be looked up as
* a keyword.
*/
private void convertStringTo(Aast node, int newtype)
throws TokenStreamException,
NoViableAltException
{
if (node.getType() != STRING)
{
throw new RuntimeException("Node must be a STRING type!");
}
// remove the outer quotes, handle escapes etc...
String clean = character.progressToJavaString(node.getText(), !unixEscapes, false);
if (newtype == -1)
{
// simulate the keyword processing that would have happened if this wasn't a string
Keyword found = sym.lookupKeyword(clean);
if (found != null)
{
newtype = found.getTokenType();
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
// set the new token type and text
saveAndReplaceTypeAndText(node, newtype, clean);
}
/**
* Helper function to convert a {@code SYMBOL} to {@code STRING} node with the proper annotations.
*
* @param node
* The node to modify. Must be of type {@code SYMBOL}.
*/
private void convertSymbolToString(Aast node)
{
if (node.getType() != SYMBOL)
{
throw new RuntimeException("Node must be a SYMBOL type!");
}
// set the new token type and text
saveAndReplaceTypeAndText(node, STRING, "\"" + node.getText() + "\"");
node.putAnnotation("is-literal", true);
}
/**
* Helper function to replace the current token text and type with the given values, but first
* original type and text values are saved in annotations named 'oldtype' and 'original-text'.
*
* @param node
* The AST to annotate and modify.
* @param newtype
* The new type of the target node.
* @param newtxt
* The new text of the target node.
*/
private void saveAndReplaceTypeAndText(Aast node, int newtype, String newtxt)
{
saveAndReplaceType(node, newtype);
saveAndReplaceText(node, newtxt);
}
/**
* Helper function to replace the current token text with the given text, but first the
* original text is saved in an annotation named 'original-text'.
*
* @param node
* The AST to annotate and modify.
* @param newtxt
* The new text of the target node.
*/
private void saveAndReplaceText(Aast node, String newtxt)
{
// save off the old token type
String oldtxt = node.getText();
// set the new token text
node.setText(newtxt);
// save any original token text
if (node.getAnnotation("original-text") == null && oldtxt != null)
{
node.putAnnotation("original-text", oldtxt);
}
}
/**
* Helper function to replace the current token type with a new token
* type, but first saving off the old type and then storing that old
* token type in an annotation named 'oldtype'.
*
* @param node
* The AST to annotate and modify.
* @param newtype
* The new type of the target node.
*/
private void saveAndReplaceType(Aast node, int newtype)
{
// save off the old token type
int oldtype = node.getType();
// set the new token type
node.setType(newtype);
// save any original token type that rewriting may have erased
// as an annotation (unless the oldtype is already set)
if (!node.isAnnotation("oldtype"))
{
node.putAnnotation("oldtype", Long.valueOf(oldtype));
}
}
/**
* The 4GL seems to disambiguate assignment statements from usage of the EQUALS operator, by
* examining the lvalue. If the lvalue is of a type that cannot be assigned to, then the
* operator is treated as an EQUALS not an ASSIGN. This code attempts to do the same
* detection and will rewrite the operator node to an EQUALS (it will be passed in as an
* ASSIGN).
*
* @param lnode
* The lvalue AST to examine.
* @param opnode
* The operator AST to edit.
*
* @return <code>true</code> if the operator was edited.
*/
private boolean restoreEqualsOperator(Aast lnode, Aast opnode)
{
if (lnode != null && opnode != null)
{
int type = lnode.getType();
// object methods can be "bare" (within a class definition a method call can
// be made without an object reference and colon operator) but normally they
// use the COLON operator; handle references and COM automation cannot be
// bare, they always use an operator
if (type == COLON || type == OBJECT_INVOCATION || type == COM_INVOCATION)
{
// in these cases we find the result type of the sub-expression by looking
// at the 2nd child of the operator (even in a deeply nested chaining case)
lnode = lnode.getChildAt(1);
type = lnode.getType();
}
if ((type >= BEGIN_FUNCTYPES && type <= END_FUNCTYPES) ||
(type >= BEGIN_METH && type <= END_METH) ||
(type >= BEGIN_OO_METH && type <= END_OO_METH) ||
type == COM_METHOD ||
isLiteral(lnode))
{
opnode.setType(EQUALS);
return true;
}
}
return false;
}
/**
* Report if the node is a literal.
*
* @param node
* The node AST to examine.
*
* @return <code>true</code> if the node is a literal.
*/
private boolean isLiteral(Aast node)
{
return node.isAnnotation("is-literal") && (Boolean) node.getAnnotation("is-literal");
}
/**
* Some parts of the parser can match a function when it should have matched the same name
* as an "lvalue-like" language statement. Such matches would be a mistake (since we can't
* properly lookahead the arbitrary amount needed to detect if there is an EQUALS token.
* Instead, we detect the problem here and rewrite the node to "undo" the damage.
*
* @param node
* The AST to restore.
*
* @return <code>true</code> if the node was edited.
*/
private boolean restoreAssignStyleStmt(Aast node)
{
if (node.isAnnotation("oldtype") &&
(node.getType() < BEGIN_VARTYPES || node.getType() > END_VARTYPES))
{
Long otype = (Long) node.getAnnotation("oldtype");
if (otype == KW_CUR_VAL || otype == KW_DYN_CURV || otype == KW_DYN_PROP || otype == KW_ENTRY ||
otype == KW_SUBSTR || otype == KW_EXTENT || otype == KW_LENGTH || otype == KW_RAW)
{
node.setType(otype.intValue());
node.removeAnnotation("oldtype");
node.removeAnnotation("builtin");
node.removeAnnotation("returnsunknown");
return true;
}
}
return false;
}
/**
* Helper to instantiate a new (limited use) lexer and re-lex the input.
* The problem is that some initializers have non-strings 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
* quote characters 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 single or double quoted enclosed string containing a
* token to lex. MUST NOT be <code>null</code>. MUST have
* enclosing quote characters as the first AND last characters.
*
* @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 TokenStreamException
{
// we can't just remove the first and last char because string options can be present
// for example, "<content_or_not>":U
String cleaner = character.progressToJavaString(input, !unixEscapes, false);
if ("".equals(cleaner))
return null;
SymbolResolver sr = new SymbolResolver(false);
// 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();
}
/**
* Loads the <code>SymbolResolver</code> with Progress 4GL built-in
* functions (which take parameters). This is called during construction
* to ensure that the functions are available before parsing begins.
* <p>
* Each function is added with the full name (even if the keyword supports
* abbreviations) because the {@link #func_call} method will detect when
* a keyword is being used and it will use the keyword dictionary to
* handle the abbreviation support. This lookup will convert any
* abbreviated text to the full text before lookup in the function
* dictionary.
* <p>
* All functions are added with the token type associated with their
* respective return value. Some built-in functions may have the special
* type of <code>FUNC_POLY</code>. This special type indicates that the
* function can return multiple different return types. The built-in
* functions typically implement the return type based on the type of the
* parameters passed. User-defined functions cannot provide the same
* feature, this can only occur in built-in functions.
* <p>
* Built-in functions that have no parameters are treated as variables.
* See {@link #initializeVariableDictionary}.
* <p>
* Note that there are some built-in functions that can act like variables
* OR as a normal parenthesized function. In other words, for the
* following list, the parenthesis are optional:
* <p>
* <ul>
* <li>AUDIT-ENABLED
* <li>ETIME
* <li>FRAME-COL
* <li>FRAME-DOWN
* <li>FRAME-LINE
* <li>FRAME-ROW
* <li>LINE-COUNTER
* <li>PAGE-NUMBER
* <li>PAGE-SIZE
* <li>SUPER (handled in the super_function rule, not here)
* <li>USERID (and it's synonym USER which is not an abbreviation)
* </ul>
* <p>
* Such variables/functions are included in both this rule and in
* <code>initializeVariableDictionary</code>.
*/
private void initializeFunctionDictionary()
{
if (sym.isRuntimeConfig())
{
// already initialized from an exemplar
return;
}
sym.addBuiltinFunction("_cbit" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("_msg" , FUNC_INT , true );
sym.addBuiltinFunction("absolute" , FUNC_POLY , true ); // INT or DEC
sym.addBuiltinFunction("accumulate" , FUNC_POLY , false); // used for annotations only, matches keyword text not actual function name
sym.addBuiltinFunction("add-interval" , FUNC_POLY , false); // DATE, DATETIME or DATETIME-TZ
sym.addBuiltinFunction("alias" , FUNC_CHAR , true );
sym.addBuiltinFunction("ambiguous" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("ascending" , FUNC_INT , true ); // this is a synonym for ASC
sym.addBuiltinFunction("audit-enabled" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("available" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("base64-decode" , FUNC_MEMPTR , false);
sym.addBuiltinFunction("base64-encode" , FUNC_LONGCHAR , false);
sym.addBuiltinFunction("box" , FUNC_CLASS , true , "System.Object"); // TODO: this qualified class is wrong but we need a placeholder
sym.addBuiltinFunction("can-do" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("can-find" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("can-query" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("can-set" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("caps" , FUNC_CHAR , true );
sym.addBuiltinFunction("cast" , FUNC_CLASS , true ); // used for annotations only
sym.addBuiltinFunction("chr" , FUNC_CHAR , true );
sym.addBuiltinFunction("codepage-convert" , FUNC_CHAR , true );
sym.addBuiltinFunction("compare" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("connected" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("count-of" , FUNC_INT , false);
sym.addBuiltinFunction("current-changed" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("current-result-row" , FUNC_INT , true );
sym.addBuiltinFunction("current-value" , FUNC_INT64 , true ); // used for annotations only
sym.addBuiltinFunction("data-source-modified" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("date" , FUNC_DATE , true );
sym.addBuiltinFunction("datetime" , FUNC_DATETIME , false);
sym.addBuiltinFunction("datetime-tz" , FUNC_DATETIME_TZ, false);
sym.addBuiltinFunction("day" , FUNC_INT , true );
sym.addBuiltinFunction("dbcodepage" , FUNC_CHAR , true );
sym.addBuiltinFunction("dbcollation" , FUNC_CHAR , true );
sym.addBuiltinFunction("dbparam" , FUNC_CHAR , true );
sym.addBuiltinFunction("db-remote-host" , FUNC_CHAR , true );
sym.addBuiltinFunction("dbrestrictions" , FUNC_CHAR , true );
sym.addBuiltinFunction("dbtaskid" , FUNC_INT , true );
sym.addBuiltinFunction("dbtype" , FUNC_CHAR , true );
sym.addBuiltinFunction("dbversion" , FUNC_CHAR , true );
sym.addBuiltinFunction("decimal" , FUNC_DEC , true );
sym.addBuiltinFunction("decrypt" , FUNC_MEMPTR , false);
sym.addBuiltinFunction("disable-redraw" , FUNC_LOGICAL , false); // not real 4GL, this is a FWD extension
sym.addBuiltinFunction("dynamic-cast" , FUNC_CLASS , true , "Progress.Lang.Object"); // TODO: this qualified class is wrong but we need a placeholder
sym.addBuiltinFunction("dynamic-current-value", FUNC_INT64 , false);
sym.addBuiltinFunction("dynamic-enum" , FUNC_CLASS , true, "Progress.Lang.Enum");
sym.addBuiltinFunction("dynamic-function" , FUNC_POLY , true ); // like called func, uses for annotations only
sym.addBuiltinFunction("dynamic-invoke" , FUNC_POLY , true );
sym.addBuiltinFunction("dynamic-new" , FUNC_CLASS , true , "Progress.Lang.Object"); // used for annotations only
sym.addBuiltinFunction("dynamic-next-value" , FUNC_INT64 , false);
sym.addBuiltinFunction("dynamic-property" , FUNC_POLY , true );
sym.addBuiltinFunction("encode" , FUNC_CHAR , true );
sym.addBuiltinFunction("encrypt" , FUNC_MEMPTR , false);
sym.addBuiltinFunction("entered" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("entry" , FUNC_CHAR , true );
sym.addBuiltinFunction("error" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("etime" , FUNC_INT64 , false);
sym.addBuiltinFunction("exp" , FUNC_DEC , true );
sym.addBuiltinFunction("extent" , FUNC_INT , false);
sym.addBuiltinFunction("fill" , FUNC_CHAR , true );
sym.addBuiltinFunction("first" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("first-of" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("frame-col" , FUNC_DEC , false);
sym.addBuiltinFunction("frame-down" , FUNC_INT , false);
sym.addBuiltinFunction("frame-line" , FUNC_INT , false);
sym.addBuiltinFunction("frame-row" , FUNC_DEC , false);
sym.addBuiltinFunction("generate-pbe-key" , FUNC_RAW , false);
sym.addBuiltinFunction("get-bits" , FUNC_INT , true );
sym.addBuiltinFunction("get-byte" , FUNC_INT , true );
sym.addBuiltinFunction("get-byte-order" , FUNC_INT , false);
sym.addBuiltinFunction("get-bytes" , FUNC_POLY , true ); // RAW or MEMPTR
sym.addBuiltinFunction("get-class" , FUNC_CLASS , false, "Progress.Lang.Class"); // found in customer code
sym.addBuiltinFunction("get-codepages" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-collation" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-collations" , FUNC_CHAR , true );
sym.addBuiltinFunction("get-db-client" , FUNC_HANDLE , false);
sym.addBuiltinFunction("get-double" , FUNC_DEC , true );
sym.addBuiltinFunction("get-float" , FUNC_DEC , true );
sym.addBuiltinFunction("get-int64" , FUNC_INT64 , false);
sym.addBuiltinFunction("get-license" , FUNC_INT , true ); // undocumented function seen in Possenet code (see adecomm/_toollic.p)
sym.addBuiltinFunction("get-long" , FUNC_INT , true );
sym.addBuiltinFunction("get-pointer-value" , FUNC_INT64 , false);
sym.addBuiltinFunction("get-short" , FUNC_INT , true );
sym.addBuiltinFunction("get-size" , FUNC_INT64 , false);
sym.addBuiltinFunction("get-string" , FUNC_CHAR , true );
sym.addBuiltinFunction("get-unsigned-short" , FUNC_INT , true );
sym.addBuiltinFunction("get-unsigned-long" , FUNC_INT64 , false);
sym.addBuiltinFunction("get-working-directory", FUNC_CHAR , false); // not real 4GL, this is a FWD extension
sym.addBuiltinFunction("guid" , FUNC_CHAR , false);
sym.addBuiltinFunction("handle" , FUNC_HANDLE , false);
sym.addBuiltinFunction("hash-code" , FUNC_INT , true );
sym.addBuiltinFunction("hex-decode" , FUNC_RAW , false);
sym.addBuiltinFunction("hex-encode" , FUNC_CHAR , false);
sym.addBuiltinFunction("hwnd" , FUNC_HANDLE , false); // FWD extension, not real 4GL!
sym.addBuiltinFunction("if" , FUNC_POLY , true ); // used for annotations only
sym.addBuiltinFunction("index" , FUNC_INT , true );
sym.addBuiltinFunction("input" , FUNC_POLY , false); // used for annotations only
sym.addBuiltinFunction("integer" , FUNC_INT , true );
sym.addBuiltinFunction("int64" , FUNC_INT64 , false);
sym.addBuiltinFunction("interval" , FUNC_INT64 , false);
sym.addBuiltinFunction("is-codepage-fixed" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("is-column-codepage" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("is-db-multi-tenant" , FUNC_LOGICAL , false); // Added when found in customer code
sym.addBuiltinFunction("is-lead-byte" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("iso-date" , FUNC_CHAR , false);
sym.addBuiltinFunction("kblabel" , FUNC_CHAR , true );
sym.addBuiltinFunction("keycode" , FUNC_INT , true );
sym.addBuiltinFunction("key-code" , FUNC_INT , true );
sym.addBuiltinFunction("keyfunction" , FUNC_CHAR , true );
sym.addBuiltinFunction("key-function" , FUNC_CHAR , true );
sym.addBuiltinFunction("keylabel" , FUNC_CHAR , true );
sym.addBuiltinFunction("key-label" , FUNC_CHAR , true );
sym.addBuiltinFunction("keyword" , FUNC_CHAR , true );
sym.addBuiltinFunction("keyword-all" , FUNC_CHAR , true );
sym.addBuiltinFunction("last" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("last-of" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("lc" , FUNC_CHAR , true );
sym.addBuiltinFunction("ldbname" , FUNC_CHAR , true );
sym.addBuiltinFunction("left-trim" , FUNC_CHAR , true );
sym.addBuiltinFunction("length" , FUNC_INT , true );
sym.addBuiltinFunction("library" , FUNC_CHAR , true );
sym.addBuiltinFunction("line-counter" , FUNC_INT , false);
sym.addBuiltinFunction("list-events" , FUNC_CHAR , true );
sym.addBuiltinFunction("list-query-attrs" , FUNC_CHAR , true );
sym.addBuiltinFunction("list-set-attrs" , FUNC_CHAR , true );
sym.addBuiltinFunction("list-widgets" , FUNC_CHAR , true );
sym.addBuiltinFunction("load-picture" , FUNC_COM_HANDLE , true ); // supposed to be a "statement" but really acts like a function
sym.addBuiltinFunction("locked" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("log" , FUNC_DEC , true );
sym.addBuiltinFunction("logical" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("lookup" , FUNC_INT , true );
sym.addBuiltinFunction("lower" , FUNC_CHAR , true );
sym.addBuiltinFunction("maximum" , FUNC_POLY , true ); // same as parms
sym.addBuiltinFunction("md5-digest" , FUNC_RAW , false);
sym.addBuiltinFunction("member" , FUNC_CHAR , true );
sym.addBuiltinFunction("message-digest" , FUNC_RAW , false);
sym.addBuiltinFunction("minimum" , FUNC_POLY , true ); // same as parms
sym.addBuiltinFunction("month" , FUNC_INT , true );
sym.addBuiltinFunction("mtime" , FUNC_INT , false);
sym.addBuiltinFunction("new" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("next-value" , FUNC_INT64 , true ); // used for annotations only
sym.addBuiltinFunction("normalize" , FUNC_POLY , false); // CHAR or LONGCHAR
sym.addBuiltinFunction("not entered" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("now" , FUNC_DATETIME_TZ, true );
sym.addBuiltinFunction("num-entries" , FUNC_INT , true );
sym.addBuiltinFunction("num-results" , FUNC_INT , true );
sym.addBuiltinFunction("os-getenv" , FUNC_CHAR , true );
sym.addBuiltinFunction("p2j-remote-call" , FUNC_CHAR , true ); // P2J-extension, not real 4GL!
sym.addBuiltinFunction("page-number" , FUNC_INT , false);
sym.addBuiltinFunction("page-size" , FUNC_INT , false);
sym.addBuiltinFunction("pdbname" , FUNC_CHAR , true );
sym.addBuiltinFunction("program-name" , FUNC_CHAR , true );
sym.addBuiltinFunction("query-off-end" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("quoter" , FUNC_CHAR , false);
sym.addBuiltinFunction("r-index" , FUNC_INT , true );
sym.addBuiltinFunction("raw" , FUNC_RAW , false);
sym.addBuiltinFunction("random" , FUNC_INT , true );
sym.addBuiltinFunction("recid" , FUNC_RECID , true ); // used for annotations only
sym.addBuiltinFunction("record-length" , FUNC_INT , false); // used for annotations only
sym.addBuiltinFunction("rejected" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("replace" , FUNC_CHAR , true );
sym.addBuiltinFunction("proversion" , FUNC_LOGICAL , true ); // used for annotations only
sym.addBuiltinFunction("retry" , FUNC_LOGICAL , true ); // used for annotations only
sym.addBuiltinFunction("rgb-value" , FUNC_INT , true );
sym.addBuiltinFunction("right-trim" , FUNC_CHAR , true );
sym.addBuiltinFunction("round" , FUNC_DEC , true );
sym.addBuiltinFunction("rowid" , FUNC_ROWID , true ); // used for annotations only
sym.addBuiltinFunction("row-state" , FUNC_INT , false); // used for annotations only
sym.addBuiltinFunction("sdbname" , FUNC_CHAR , true );
sym.addBuiltinFunction("search" , FUNC_CHAR , true );
sym.addBuiltinFunction("seek" , FUNC_INT , true );
sym.addBuiltinFunction("setuserid" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("set-db-client" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("set-working-directory", FUNC_LOGICAL , false); // not real 4GL, this is a FWD extension
sym.addBuiltinFunction("sha1-digest" , FUNC_RAW , false);
sym.addBuiltinFunction("sqrt" , FUNC_DEC , true );
sym.addBuiltinFunction("ssl-server-name" , FUNC_CHAR , false);
sym.addBuiltinFunction("string" , FUNC_CHAR , true );
sym.addBuiltinFunction("substitute" , FUNC_CHAR , true );
sym.addBuiltinFunction("substring" , FUNC_CHAR , true );
sym.addBuiltinFunction("super" , FUNC_POLY , true ); // used for annotations only
sym.addBuiltinFunction("tenant-id" , FUNC_INT , true ); // found in customer code
sym.addBuiltinFunction("tenant-name" , FUNC_CHAR , true ); // found in customer code
sym.addBuiltinFunction("tenant-name-to-id" , FUNC_INT , true ); // found in customer code
sym.addBuiltinFunction("time" , FUNC_INT , false); // used for annotations only
sym.addBuiltinFunction("timezone" , FUNC_INT , false);
sym.addBuiltinFunction("to-rowid" , FUNC_ROWID , true );
sym.addBuiltinFunction("today" , FUNC_DATE , false); // used for annotations only
sym.addBuiltinFunction("trans" , FUNC_LOGICAL , true ); // used for annotations only
sym.addBuiltinFunction("transaction" , FUNC_LOGICAL , true ); // used for annotations only
sym.addBuiltinFunction("trim" , FUNC_CHAR , true );
sym.addBuiltinFunction("truncate" , FUNC_DEC , true );
sym.addBuiltinFunction("type-of" , FUNC_LOGICAL , false); // used for annotations only
sym.addBuiltinFunction("unbox" , FUNC_POLY , true );
sym.addBuiltinFunction("upper" , FUNC_CHAR , true );
sym.addBuiltinFunction("user" , FUNC_CHAR , false);
sym.addBuiltinFunction("userid" , FUNC_CHAR , false);
sym.addBuiltinFunction("url-encode" , FUNC_CHAR , false); // not real 4GL built-in, this one is being added as a FWD extension; normally it comes with webspeed (4GL code in src/web/method/cgiutils.i)
sym.addBuiltinFunction("valid-event" , FUNC_LOGICAL , true );
sym.addBuiltinFunction("valid-handle" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("valid-object" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("weekday" , FUNC_INT , true );
sym.addBuiltinFunction("widget-handle" , FUNC_HANDLE , true );
sym.addBuiltinFunction("xpr-to-pdf" , FUNC_LOGICAL , false); // not real 4GL, this is a FWD extension
sym.addBuiltinFunction("year" , FUNC_INT , true );
if (webspeed)
{
// add our "fake" webspeed built-in functions
sym.addBuiltinFunction("available-messages" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("check-agent-mode" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("convert-datetime" , FUNC_CHAR , false);
sym.addBuiltinFunction("delete-cookie" , FUNC_CHAR , true );
sym.addBuiltinFunction("format-datetime" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-cgi" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-cgi-long" , FUNC_LONGCHAR, false);
sym.addBuiltinFunction("get-config" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-cookie" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-field" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-long-value" , FUNC_LONGCHAR, false);
sym.addBuiltinFunction("get-message-groups" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-messages" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-user-field" , FUNC_CHAR , false);
sym.addBuiltinFunction("get-value" , FUNC_CHAR , false);
sym.addBuiltinFunction("hidden-field" , FUNC_CHAR , false);
sym.addBuiltinFunction("hidden-field-list" , FUNC_CHAR , false);
sym.addBuiltinFunction("html-encode" , FUNC_CHAR , false);
sym.addBuiltinFunction("output-content-type", FUNC_LOGICAL , false);
sym.addBuiltinFunction("output-http-header" , FUNC_CHAR , false);
sym.addBuiltinFunction("output-messages" , FUNC_INT , false);
sym.addBuiltinFunction("queue-message" , FUNC_INT , false);
sym.addBuiltinFunction("set-cookie" , FUNC_CHAR , false);
sym.addBuiltinFunction("set-user-field" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("setwebstate" , FUNC_LOGICAL , false);
sym.addBuiltinFunction("url-decode" , FUNC_CHAR , false);
sym.addBuiltinFunction("url-field" , FUNC_CHAR , false);
sym.addBuiltinFunction("url-field-list" , FUNC_CHAR , false);
sym.addBuiltinFunction("url-format" , FUNC_CHAR , false);
}
}
/**
* Loads the <code>SymbolResolver</code> with Progress 4GL attributes and
* methods. This is called during construction to ensure that resolution
* is available before parsing begins.
* <p>
* Each attribute or method is added with the keyword's token type as the
* key and the data type (attributes) or return type (methods) as the
* mapped value.
*/
private void initializeAttributesDictionary()
{
if (sym.isRuntimeConfig())
{
// already initialized from an exemplar
return;
}
sym.addAllAttributesAndMethods(getAttributesAndMethods());
sym.setAttributeOrMethodType( KW_CUR_RQI , "Progress.Lang.OERequestInfo" );
sym.setAttributeOrMethodType( KW_CUR_RSI , "Progress.Lang.OERequestInfo" );
sym.setAttributeOrMethodType( KW_FIRST_FM, "Progress.Windows.IForm" );
sym.setAttributeOrMethodType( KW_FIRST_OB, SymbolResolver.ROOT_OBJ_NAME );
sym.setAttributeOrMethodType( KW_LAST_FRM, "Progress.Windows.IForm" );
sym.setAttributeOrMethodType( KW_LAST_OBJ, SymbolResolver.ROOT_OBJ_NAME );
sym.setAttributeOrMethodType( KW_LOC_V_I , "Progress.Lang.OEVersionInfo" );
sym.setAttributeOrMethodType( KW_REQ_INFO, "Progress.Lang.OERequestInfo" );
sym.setAttributeOrMethodType( KW_RSP_INFO, "Progress.Lang.OERequestInfo" );
}
/**
* Defines all built-in system handles in 4GL.
* <p>
* Any change in this list must be reflected in the {@link Call#setInHandle(String)} API, as
* a system handle can be referenced by its name, via the CALL:IN-HANDLE attribute.
*
* @return A set of system handle names.
*/
public static Set<String> getSysHandles()
{
Set<String> res = new HashSet();
res.add("active-window");
res.add("audit-control");
res.add("audit-policy");
res.add("clipboard");
res.add("codebase-locator");
res.add("color-table");
res.add("com-self");
res.add("compiler");
res.add("current-window");
res.add("debugger");
res.add("default-window");
res.add("dslog-manager");
res.add("error-status");
res.add("file-information");
res.add("focus");
res.add("font-table");
res.add("last-event");
res.add("log-manager");
res.add("profiler");
res.add("rcode-information");
res.add("security-policy");
res.add("self");
res.add("session");
res.add("source-procedure");
res.add("target-procedure");
res.add("this-procedure");
res.add("web-context");
return res;
}
/**
* Get a map with the type of all known attributes and methods.
*
* @return See above.
*/
public static Map<Integer, Integer> getAttributesAndMethods()
{
Map<Integer, Integer> attrsAndMethods = new HashMap<>();
attrsAndMethods.put( KW_ACCEL, ATTR_CHAR );
attrsAndMethods.put( KW_ACC_CHG , METH_LOGICAL );
attrsAndMethods.put( KW_ACC_RCHG, METH_LOGICAL );
attrsAndMethods.put( KW_ACTIVATE, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ACTIVE , ATTR_LOGICAL );
attrsAndMethods.put( KW_ACTOR , ATTR_CHAR );
attrsAndMethods.put( KW_ADD_BCCA, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_BUF , METH_LOGICAL );
attrsAndMethods.put( KW_ADD_CC_A, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_C_C , METH_HANDLE );
attrsAndMethods.put( KW_ADD_C_F , METH_LOGICAL );
attrsAndMethods.put( KW_ADD_EVTP, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_F_F , METH_LOGICAL );
attrsAndMethods.put( KW_ADD_1ST , METH_LOGICAL );
attrsAndMethods.put( KW_ADD_C_N, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_F_N, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_L_N, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_N_N, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_HENT, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_IDXF, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_IMG, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_LAST, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_L_C , METH_HANDLE );
attrsAndMethods.put( KW_ADD_LIKF, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_LIKI, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_NEWF, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_NEWI, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_PREL, METH_HANDLE );
attrsAndMethods.put( KW_ADD_REL , METH_HANDLE );
attrsAndMethods.put( KW_ADD_SLOC, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_SRCB, METH_LOGICAL );
attrsAndMethods.put( KW_ADD_SUP , METH_LOGICAL );
attrsAndMethods.put( KW_ADD_TAB , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADD_TO_A, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ADM_DATA, ATTR_CHAR );
attrsAndMethods.put( KW_AFT_BUFF, ATTR_HANDLE );
attrsAndMethods.put( KW_AFT_ROID, ATTR_ROWID );
attrsAndMethods.put( KW_AFT_TBL , ATTR_HANDLE );
attrsAndMethods.put( KW_ALLW_C_S, ATTR_LOGICAL );
attrsAndMethods.put( KW_ALW_ON_T, ATTR_LOGICAL );
attrsAndMethods.put( KW_AMBIG , ATTR_LOGICAL );
attrsAndMethods.put( KW_APPEND_C, METH_LOGICAL );
attrsAndMethods.put( KW_APPL_A_B, ATTR_LOGICAL );
attrsAndMethods.put( KW_APPL_CID, ATTR_CHAR );
attrsAndMethods.put( KW_APPL_CBK, METH_LOGICAL );
attrsAndMethods.put( KW_APP_INFO, ATTR_CHAR );
attrsAndMethods.put( KW_APP_PW , ATTR_CHAR );
attrsAndMethods.put( KW_APP_UID , ATTR_CHAR );
attrsAndMethods.put( KW_AST_ACTI, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ASYNC , ATTR_LOGICAL );
attrsAndMethods.put( KW_ASYNC_RC, ATTR_INT );
attrsAndMethods.put( KW_ASYNC_RH, ATTR_HANDLE );
attrsAndMethods.put( KW_ATT_DSRC, METH_LOGICAL );
attrsAndMethods.put( KW_ATT_FILE, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ATT_PLST, ATTR_CHAR );
attrsAndMethods.put( KW_ATT_URL, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ATTR , ATTR_LOGICAL );
attrsAndMethods.put( KW_ATTR_NAM, ATTR_CHAR );
attrsAndMethods.put( KW_AUD_EV_C, ATTR_CHAR );
attrsAndMethods.put( KW_AUTHBLOB, ATTR_CHAR );; // FWD extension, not real 4GL
attrsAndMethods.put( KW_AUTHEN_F, METH_LOGICAL );
attrsAndMethods.put( KW_AUTO_COM, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_DEL, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_D_X, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_END, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_GO , ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_IND, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_RES, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_RET, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_SYN, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_VAL, ATTR_LOGICAL );
attrsAndMethods.put( KW_AUTO_ZAP, ATTR_LOGICAL );
attrsAndMethods.put( KW_AVAIL , ATTR_LOGICAL );
attrsAndMethods.put( KW_AVL_FMTS, ATTR_CHAR );
attrsAndMethods.put( KW_BACKGRND, ATTR_HANDLE );
attrsAndMethods.put( KW_BAS_LOGG, ATTR_LOGICAL );
attrsAndMethods.put( KW_BASE_ADE, ATTR_CHAR );
attrsAndMethods.put( KW_BATCH_MO, ATTR_LOGICAL );
attrsAndMethods.put( KW_BATCH_SZ, ATTR_INT );
attrsAndMethods.put( KW_B4_BUFF , ATTR_HANDLE );
attrsAndMethods.put( KW_B4_ROWID, ATTR_ROWID );
attrsAndMethods.put( KW_B4_TABLE, ATTR_HANDLE );
attrsAndMethods.put( KW_BEG_EV_G, METH_CHAR );
attrsAndMethods.put( KW_BGCOLOR , ATTR_INT );
attrsAndMethods.put( KW_BGCOLRGB, ATTR_INT ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_BLANK , ATTR_LOGICAL );
attrsAndMethods.put( KW_BLK_IT_D, ATTR_LOGICAL );
attrsAndMethods.put( KW_BL_CURGR ,ATTR_HANDLE ); // FWD Ext. Attr: ButtonList:CurrentGroup
attrsAndMethods.put( KW_BL_CGR_K ,ATTR_CHAR ); // FWD Ext. Attr: ButtonList:CurrentGroup-Key
attrsAndMethods.put( KW_BL_BTNFN ,ATTR_INT ); // FWD Ext. Attr: ButtonList:ButtonFont
attrsAndMethods.put( KW_BL_ITMFN ,ATTR_INT ); // FWD Ext. Attr: ButtonList:ItemFont
attrsAndMethods.put( KW_BL_GCLR ,METH_LOGICAL ); // FWD Ext. Method: ButtonList:Clear-ButtonList
attrsAndMethods.put( KW_BL_GADD ,METH_HANDLE ); // FWD Ext. Method: ButtonList:Add-Group
attrsAndMethods.put( KW_BL_GIFP ,METH_HANDLE ); // FWD Ext. Method: ButtonListGroup:Item-FromPosition
attrsAndMethods.put( KW_BL_IADD ,METH_HANDLE ); // FWD Ext. Method: ButtonListGroup:Add-Item
attrsAndMethods.put( KW_BL_G_KEY ,ATTR_CHAR ); // FWD Ext. Attr: ButtonListGroup:Group-Key
attrsAndMethods.put( KW_BL_GIKEY ,ATTR_CHAR ); // FWD Ext. Attr: ButtonListGroupItem:Item-Key
attrsAndMethods.put( KW_BL_NGR , ATTR_INT ); // FWD Ext. Attr: ButtonList:Num-Groups
attrsAndMethods.put( KW_BL_NGRI , ATTR_INT ); // FWD Ext. Attr: ButtonListGroup:Num-Group-Items
attrsAndMethods.put( KW_BL_G_GR ,METH_HANDLE ); // FWD Ext. Method: ButtonList:Get-Group
attrsAndMethods.put( KW_BL_G_GRI ,METH_HANDLE ); // FWD Ext. Method: ButtonListGroup:Get-Group-Item
attrsAndMethods.put( KW_BORD_B_C, ATTR_DEC );
attrsAndMethods.put( KW_BORD_B_P, ATTR_INT );
attrsAndMethods.put( KW_BORD_L_C, ATTR_DEC );
attrsAndMethods.put( KW_BORD_L_P, ATTR_INT );
attrsAndMethods.put( KW_BORD_R_C, ATTR_DEC );
attrsAndMethods.put( KW_BORD_R_P, ATTR_INT );
attrsAndMethods.put( KW_BORD_T_C, ATTR_DEC );
attrsAndMethods.put( KW_BORD_T_P, ATTR_INT );
attrsAndMethods.put( KW_BOX , ATTR_LOGICAL );
attrsAndMethods.put( KW_BOX_SEL , ATTR_LOGICAL );
attrsAndMethods.put( KW_BR_AGENT, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_BR_IP , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_BR_PORT , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_BR_TZ , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_BUFFER_C, ATTR_INT );
attrsAndMethods.put( KW_BUFFER_L, ATTR_INT );
attrsAndMethods.put( KW_BUF_COMP, METH_LOGICAL );
attrsAndMethods.put( KW_BUF_COPY, METH_LOGICAL );
attrsAndMethods.put( KW_BUF_CREA, METH_LOGICAL );
attrsAndMethods.put( KW_BUF_DEL , METH_LOGICAL );
attrsAndMethods.put( KW_BUF_FLD , ATTR_HANDLE ); // warning: this can have LPARENS-based subscripting!
attrsAndMethods.put( KW_BUF_GRPI, ATTR_INT );
attrsAndMethods.put( KW_BUF_GRPN, ATTR_CHAR );
attrsAndMethods.put( KW_BUF_HNDL, ATTR_HANDLE );
attrsAndMethods.put( KW_BUF_NAME, ATTR_CHAR );
attrsAndMethods.put( KW_BUF_PARI, ATTR_INT );
attrsAndMethods.put( KW_BUF_REL , METH_LOGICAL );
attrsAndMethods.put( KW_BUF_TENI, ATTR_INT );
attrsAndMethods.put( KW_BUF_TENN, ATTR_CHAR );
attrsAndMethods.put( KW_BUF_VLID, METH_LOGICAL );
attrsAndMethods.put( KW_BUF_VAL , ATTR_POLY );
attrsAndMethods.put( KW_BUILD_TR, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_BYTES_R , ATTR_INT );
attrsAndMethods.put( KW_BYTES_W , ATTR_INT );
attrsAndMethods.put( KW_CACHE, ATTR_INT );
attrsAndMethods.put( KW_CALBGCLR, ATTR_INT ); // FWD CALENDAR:CalendarBackColor extension, not real 4GL
attrsAndMethods.put( KW_CALCUFMT, ATTR_CHAR ); // FWD CALENDAR:CustomFormat extension, not real 4GL
attrsAndMethods.put( KW_CALFGCLR, ATTR_INT ); // FWD CALENDAR:CalendarForeColor extension, not real 4GL
attrsAndMethods.put( KW_CALFMTST, ATTR_INT ); // FWD CALENDAR:FormatStyle extension, not real 4GL
attrsAndMethods.put( KW_CALL_NAM, ATTR_CHAR );
attrsAndMethods.put( KW_CALL_TYP, ATTR_INT );
attrsAndMethods.put( KW_CALLBACK, ATTR_CHAR ); // FWD TIMER extension
attrsAndMethods.put( KW_CALTITBG, ATTR_INT ); // FWD CALENDAR:TitleBackColor extension, not real 4GL
attrsAndMethods.put( KW_CALTITFG, ATTR_INT ); // FWD CALENDAR:TitleForeColor extension, not real 4GL
attrsAndMethods.put( KW_CALTRLFG, ATTR_INT ); // FWD CALENDAR:TrailingForeColor extension, not real 4GL
attrsAndMethods.put( KW_CALUPDWN, ATTR_LOGICAL ); // FWD CALENDAR:UpDown extension, not real 4GL
attrsAndMethods.put( KW_CALVALUE, ATTR_CHAR ); // FWD CALENDAR:CalendarValue extension, not real 4GL
attrsAndMethods.put( KW_CANC_BRK, METH_LOGICAL );
attrsAndMethods.put( KW_CANCEL_B, ATTR_HANDLE );
attrsAndMethods.put( KW_CANCEL_R, METH_LOGICAL );
attrsAndMethods.put( KW_CANCELLD, ATTR_LOGICAL );
attrsAndMethods.put( KW_CAN_CREA, ATTR_LOGICAL );
attrsAndMethods.put( KW_CAN_DEL , ATTR_LOGICAL );
attrsAndMethods.put( KW_CAN_READ, ATTR_LOGICAL );
attrsAndMethods.put( KW_CAN_WRT , ATTR_LOGICAL );
attrsAndMethods.put( KW_CAPFNT , ATTR_INT ); // FWD extension WithCaption:CAPTIONFONT, not real 4GL
attrsAndMethods.put( KW_CAPFNTSZ, ATTR_INT ); // FWD extension WithCaption:CAPTIONFONT-SIZE, not real 4GL
attrsAndMethods.put( KW_CARE_PNT, ATTR_LOGICAL );
attrsAndMethods.put( KW_CASE_SEN, ATTR_LOGICAL );
attrsAndMethods.put( KW_CEASE, METH_VOID ); // FWD TIMER extension
attrsAndMethods.put( KW_CENTER , ATTR_LOGICAL );
attrsAndMethods.put( KW_CFG_NAME, ATTR_CHAR );
attrsAndMethods.put( KW_CHARSET , ATTR_CHAR );
attrsAndMethods.put( KW_CHECK_BO, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CHECKED , ATTR_LOGICAL );
attrsAndMethods.put( KW_NODES , ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CHLD_BUF, ATTR_HANDLE );
attrsAndMethods.put( KW_CHLD_NUM, ATTR_INT );
attrsAndMethods.put( KW_CLEA_TAB, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLEA_WIN, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLEAR , METH_LOGICAL );
attrsAndMethods.put( KW_CLR_ALL , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_AP_C, METH_LOGICAL );
attrsAndMethods.put( KW_CLR_ATTL, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_BCCL, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_CC_L, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_EMBL, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_LOG , METH_LOGICAL );
attrsAndMethods.put( KW_CLR_NIML, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_NODS, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_SEL , METH_LOGICAL );
attrsAndMethods.put( KW_CLR_S_AR, METH_LOGICAL );
attrsAndMethods.put( KW_CLR_TABS, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLR_TO_L, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLS_TYPE, ATTR_CHAR );
attrsAndMethods.put( KW_CLN_IP, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLN_PORT, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLN_TZ , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLN_TIME, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLNT_C_I, ATTR_CHAR );
attrsAndMethods.put( KW_CLNT_DIS, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CLNT_TTY, ATTR_CHAR );
attrsAndMethods.put( KW_CLNT_TYP, ATTR_CHAR );
attrsAndMethods.put( KW_CLNT_WS , ATTR_CHAR );
attrsAndMethods.put( KW_CLONE_ND, METH_LOGICAL );
attrsAndMethods.put( KW_CLOSE_LG, METH_LOGICAL );
attrsAndMethods.put( KW_CNCL_R_A, METH_LOGICAL );
attrsAndMethods.put( KW_CNTRL_BX, ATTR_LOGICAL );
attrsAndMethods.put( KW_CP , ATTR_CHAR );
attrsAndMethods.put( KW_CPY_DSET, METH_LOGICAL );
attrsAndMethods.put( KW_CPY_SATR, METH_LOGICAL );
attrsAndMethods.put( KW_CPY_TTBL, METH_LOGICAL );
attrsAndMethods.put( KW_CODE , ATTR_INT );
attrsAndMethods.put( KW_COL , ATTR_DEC );
attrsAndMethods.put( KW_COLUMNS , ATTR_DEC );
attrsAndMethods.put( KW_COL_BGC , ATTR_INT );
attrsAndMethods.put( KW_COL_CP , ATTR_CHAR );
attrsAndMethods.put( KW_COL_DC , ATTR_INT );
attrsAndMethods.put( KW_COL_FGC , ATTR_INT );
attrsAndMethods.put( KW_COL_FONT, ATTR_INT );
attrsAndMethods.put( KW_COL_LAB , ATTR_CHAR );
attrsAndMethods.put( KW_COL_MOV , ATTR_LOGICAL );
attrsAndMethods.put( KW_COL_NODE, METH_VOID ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_COL_PFC , ATTR_INT );
attrsAndMethods.put( KW_COL_R_O , ATTR_LOGICAL );
attrsAndMethods.put( KW_COL_RES , ATTR_LOGICAL );
attrsAndMethods.put( KW_COL_SCR , ATTR_LOGICAL );
attrsAndMethods.put( KW_COLL_A_E, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_COLL_ALL, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_COLOR , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_COM_HNDL, ATTR_COM_HANDLE );
attrsAndMethods.put( KW_COMPLETE, ATTR_LOGICAL );
attrsAndMethods.put( KW_CONN , METH_LOGICAL );
attrsAndMethods.put( KW_CONN_ED , METH_LOGICAL );
attrsAndMethods.put( KW_CONNTYPE, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CTX_H , ATTR_LOGICAL );
attrsAndMethods.put( KW_CTX_H_F , ATTR_CHAR );
attrsAndMethods.put( KW_CTX_H_ID, ATTR_INT );
attrsAndMethods.put( KW_CTX_PATH, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CVT_3D_C, ATTR_LOGICAL );
attrsAndMethods.put( KW_COVERAGE, ATTR_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_CPCASE , ATTR_CHAR );
attrsAndMethods.put( KW_CPCOLL , ATTR_CHAR );
attrsAndMethods.put( KW_CPINTERN, ATTR_CHAR );
attrsAndMethods.put( KW_CPLOG , ATTR_CHAR );
attrsAndMethods.put( KW_CPPRINT , ATTR_CHAR );
attrsAndMethods.put( KW_CPRCODEI, ATTR_CHAR );
attrsAndMethods.put( KW_CPRCODEO, ATTR_CHAR );
attrsAndMethods.put( KW_CPSTREAM, ATTR_CHAR );
attrsAndMethods.put( KW_CPTERM , ATTR_CHAR );
attrsAndMethods.put( KW_CRC_VAL , ATTR_INT );
attrsAndMethods.put( KW_CREAT_LK, METH_LOGICAL );
attrsAndMethods.put( KW_CREAT_SN, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CR_LK_SQ, METH_LOGICAL );
attrsAndMethods.put( KW_CRE_IMAG, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CREAT_OA, ATTR_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_CREAT_ND, METH_LOGICAL );
attrsAndMethods.put( KW_CREAT_NN, METH_LOGICAL );
attrsAndMethods.put( KW_CREAT_RL, METH_LOGICAL );
attrsAndMethods.put( KW_CRT_COL , METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CRT_MIMG, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CUR_CHG , ATTR_LOGICAL );
attrsAndMethods.put( KW_CUR_CHAR, ATTR_INT );
attrsAndMethods.put( KW_CUR_COL , ATTR_HANDLE );
attrsAndMethods.put( KW_CUR_ITER, ATTR_HANDLE );
attrsAndMethods.put( KW_CUR_LINE, ATTR_INT );
attrsAndMethods.put( KW_CUR_ENV , ATTR_CHAR );
attrsAndMethods.put( KW_CUR_OFF , ATTR_INT );
attrsAndMethods.put( KW_CUR_RES , ATTR_INT );
attrsAndMethods.put( KW_CUR_RQI , ATTR_CLASS );
attrsAndMethods.put( KW_CUR_RSI , ATTR_CLASS );
attrsAndMethods.put( KW_CUR_R_M , ATTR_LOGICAL );
attrsAndMethods.put( KW_CUR_WIN , ATTR_HANDLE );
attrsAndMethods.put( KW_CUR_QRY , METH_HANDLE );
attrsAndMethods.put( KW_CURR_TAB, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_CVT_2OFF, METH_INT );
attrsAndMethods.put( KW_ADD_TAB , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ALIGN , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DATA_E_R, ATTR_LOGICAL );
attrsAndMethods.put( KW_DATA_SCM, ATTR_CHAR );
attrsAndMethods.put( KW_DATA_SM , ATTR_LOGICAL );
attrsAndMethods.put( KW_DATA_SRC, ATTR_HANDLE );
attrsAndMethods.put( KW_DATA_SRI, ATTR_ROWID ); // assigning this is done as an attribute, but reading looks like a method with a parenthsized parameter but the 4GL docs call it an attribute
attrsAndMethods.put( KW_DATASET , ATTR_HANDLE );
attrsAndMethods.put( KW_DATATYPE, ATTR_CHAR );
attrsAndMethods.put( KW_DATE_FMT, ATTR_CHAR );
attrsAndMethods.put( KW_DATE_SEP, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DB_CTXT , ATTR_CHAR );
attrsAndMethods.put( KW_DB_JOIN , ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DB_LIST , ATTR_CHAR );
attrsAndMethods.put( KW_DB_REF , ATTR_CHAR );
attrsAndMethods.put( KW_DBNAME , ATTR_CHAR );
attrsAndMethods.put( KW_DCLK_EXP, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DCOLOR , ATTR_INT );
attrsAndMethods.put( KW_DD_OTREE, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DDE_ERR , ATTR_INT );
attrsAndMethods.put( KW_DDE_ID , ATTR_INT );
attrsAndMethods.put( KW_DDE_ITEM, ATTR_CHAR );
attrsAndMethods.put( KW_DDE_NAME, ATTR_CHAR );
attrsAndMethods.put( KW_DDE_TOPI, ATTR_CHAR );
attrsAndMethods.put( KW_DBG_ALRT, ATTR_LOGICAL );
attrsAndMethods.put( KW_DEBLANK , ATTR_LOGICAL );
attrsAndMethods.put( KW_DEBUG , METH_LOGICAL );
attrsAndMethods.put( KW_DEC_SEP , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DECIMALS, ATTR_INT );
attrsAndMethods.put( KW_DECL_NSP, METH_LOGICAL );
attrsAndMethods.put( KW_DEFAULT , ATTR_LOGICAL );
attrsAndMethods.put( KW_DEF_BUFH, ATTR_HANDLE );
attrsAndMethods.put( KW_DEF_COMM, ATTR_LOGICAL );
attrsAndMethods.put( KW_DEFLT_BN, ATTR_HANDLE );
attrsAndMethods.put( KW_DEF_STR , ATTR_CHAR );
attrsAndMethods.put( KW_DEF_VAL , ATTR_POLY );
attrsAndMethods.put( KW_DEL_CHAR, METH_LOGICAL );
attrsAndMethods.put( KW_DEL_C_R , METH_LOGICAL );
attrsAndMethods.put( KW_DEL_H_EN, METH_LOGICAL );
attrsAndMethods.put( KW_DEL_LINE, METH_LOGICAL );
attrsAndMethods.put( KW_DEL_NODE, METH_LOGICAL );
attrsAndMethods.put( KW_DEL_R_L , METH_LOGICAL );
attrsAndMethods.put( KW_DEL_S_R , METH_LOGICAL );
attrsAndMethods.put( KW_DEL_S_RS, METH_LOGICAL );
attrsAndMethods.put( KW_DELETE , METH_LOGICAL );
attrsAndMethods.put( KW_DELIMIT , ATTR_CHAR );
attrsAndMethods.put( KW_DESCR , ATTR_CHAR ); // undocumented, found in customer code
attrsAndMethods.put( KW_DESEL_R , METH_LOGICAL );
attrsAndMethods.put( KW_DESEL_FR, METH_LOGICAL );
attrsAndMethods.put( KW_DESEL_SR, METH_LOGICAL );
attrsAndMethods.put( KW_DET_DSRC, METH_LOGICAL );
attrsAndMethods.put( KW_DEVICEID, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DIRECTRY, ATTR_CHAR ); // undocumented, found in customer code
attrsAndMethods.put( KW_DIS_A_ZA, ATTR_LOGICAL );
attrsAndMethods.put( KW_DIS_CEDT, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DIS_D_TR, METH_LOGICAL );
attrsAndMethods.put( KW_DIS_L_TR, METH_LOGICAL );
attrsAndMethods.put( KW_DIS_REDR, ATTR_LOGICAL ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_DIS_STRP, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DISABL_C, METH_LOGICAL );
attrsAndMethods.put( KW_DISABLE , METH_LOGICAL );
attrsAndMethods.put( KW_DISCONN , METH_LOGICAL );
attrsAndMethods.put( KW_DISP_MSG, METH_LOGICAL );
attrsAndMethods.put( KW_DISP_TZ , ATTR_INT );
attrsAndMethods.put( KW_DISP_TYP, ATTR_CHAR );
attrsAndMethods.put( KW_DOMAIN_D, ATTR_CHAR );
attrsAndMethods.put( KW_DOMAIN_N, ATTR_CHAR );
attrsAndMethods.put( KW_DOMAIN_T, ATTR_CHAR );
attrsAndMethods.put( KW_DOWN , ATTR_INT );
attrsAndMethods.put( KW_DRAG_EN , ATTR_LOGICAL );
attrsAndMethods.put( KW_DRAGDROP, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DROP_TAR, ATTR_LOGICAL );
attrsAndMethods.put( KW_DUMP_LGN, METH_LOGICAL );
attrsAndMethods.put( KW_DYNAMIC , ATTR_LOGICAL );
attrsAndMethods.put( KW_EDGE_C , ATTR_DEC );
attrsAndMethods.put( KW_EDGE_P , ATTR_INT );
attrsAndMethods.put( KW_EDIT_C_P, ATTR_LOGICAL );
attrsAndMethods.put( KW_EDIT_C_U, ATTR_LOGICAL );
attrsAndMethods.put( KW_EDIT_CLR, METH_LOGICAL );
attrsAndMethods.put( KW_EDIT_CPY, METH_LOGICAL );
attrsAndMethods.put( KW_EDIT_CUT, METH_LOGICAL );
attrsAndMethods.put( KW_EDIT_PAS, METH_LOGICAL );
attrsAndMethods.put( KW_EDIT_UND, METH_LOGICAL );
attrsAndMethods.put( KW_EH_FL, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EH_SR, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EMB_FILE, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EMB_URL, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EMPTY , ATTR_LOGICAL );
attrsAndMethods.put( KW_EMPTY_DS, METH_LOGICAL );
attrsAndMethods.put( KW_EMPTY_TT, METH_LOGICAL );
attrsAndMethods.put( KW_ENABLE , METH_LOGICAL );
attrsAndMethods.put( KW_ENABLE_C, METH_LOGICAL );
attrsAndMethods.put( KW_ENABLE_E, METH_CHAR );
attrsAndMethods.put( KW_ENABLED , ATTR_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_ENC_AMK , METH_CHAR );
attrsAndMethods.put( KW_ENC_SALT, ATTR_RAW );
attrsAndMethods.put( KW_ENCODING, ATTR_CHAR );
attrsAndMethods.put( KW_END_DOC , METH_LOGICAL );
attrsAndMethods.put( KW_END_ELEM, METH_LOGICAL );
attrsAndMethods.put( KW_END_EV_G, METH_LOGICAL );
attrsAndMethods.put( KW_END_F_D , METH_LOGICAL );
attrsAndMethods.put( KW_END_USER, ATTR_CHAR );
attrsAndMethods.put( KW_ENS_N_V , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ENT_EX_L, ATTR_INT );
attrsAndMethods.put( KW_ENT_TLST, ATTR_CHAR );
attrsAndMethods.put( KW_ENTRY , METH_CHAR );
attrsAndMethods.put( KW_ERROR , ATTR_LOGICAL );
attrsAndMethods.put( KW_ERR_COL , ATTR_INT );
attrsAndMethods.put( KW_ERR_OBJD, ATTR_HANDLE );
attrsAndMethods.put( KW_ERR_ROW , ATTR_INT );
attrsAndMethods.put( KW_ERR_S_T , ATTR_LOGICAL );
attrsAndMethods.put( KW_ERR_STR , ATTR_CHAR );
attrsAndMethods.put( KW_EVT_ACTI, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EVT_GRID, ATTR_CHAR );
attrsAndMethods.put( KW_EVT_PROC, ATTR_CHAR );
attrsAndMethods.put( KW_EVT_TYPE, ATTR_CHAR );
attrsAndMethods.put( KW_E_PROC_C, ATTR_HANDLE );
attrsAndMethods.put( KW_EXEC_LOG, ATTR_LOGICAL );
attrsAndMethods.put( KW_EXCL_ID , ATTR_CHAR );
attrsAndMethods.put( KW_EXITCODE, ATTR_INT );
attrsAndMethods.put( KW_EXP_N_IC, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EXP_NODE, METH_VOID ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_EXP_ON_E, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EXP_SCLK, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EXPA_ALL, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_EXPAND , ATTR_LOGICAL );
attrsAndMethods.put( KW_EXPANDBL, ATTR_LOGICAL );
attrsAndMethods.put( KW_EXPORT , METH_LOGICAL );
attrsAndMethods.put( KW_EXPORT_P, METH_RAW );
attrsAndMethods.put( KW_EXTENT , ATTR_INT );
attrsAndMethods.put( KW_FETCH_SR, METH_LOGICAL );
attrsAndMethods.put( KW_FGCOLOR , ATTR_INT );
attrsAndMethods.put( KW_FGCOLRGB, ATTR_INT ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_FIL_C_D , ATTR_DATE );
attrsAndMethods.put( KW_FIL_C_T , ATTR_INT );
attrsAndMethods.put( KW_FIL_NAME, ATTR_CHAR );
attrsAndMethods.put( KW_FIL_OFF, ATTR_INT );
attrsAndMethods.put( KW_FIL_M_D , ATTR_DATE );
attrsAndMethods.put( KW_FIL_M_T , ATTR_INT );
attrsAndMethods.put( KW_FIL_SIZE, ATTR_INT );
attrsAndMethods.put( KW_FIL_TYPE, ATTR_CHAR );
attrsAndMethods.put( KW_FILL , METH_LOGICAL );
attrsAndMethods.put( KW_FILL_MOD, ATTR_CHAR );
attrsAndMethods.put( KW_FILL_WST, ATTR_CHAR );
attrsAndMethods.put( KW_FILLED , ATTR_LOGICAL );
attrsAndMethods.put( KW_FIND_BR , METH_LOGICAL );
attrsAndMethods.put( KW_FIND_CUR, METH_LOGICAL );
attrsAndMethods.put( KW_FIND_1ST, METH_LOGICAL );
attrsAndMethods.put( KW_FIND_LST, METH_LOGICAL );
attrsAndMethods.put( KW_FIND_NOD, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FIND_UNI, METH_LOGICAL );
attrsAndMethods.put( KW_FIR_DSET, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_AR, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_BU, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_CH, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_CO, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_DS, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_FM, ATTR_CLASS );
attrsAndMethods.put( KW_FIRST_N , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FIRST_OB, ATTR_CLASS );
attrsAndMethods.put( KW_FIRST_OF, METH_LOGICAL );
attrsAndMethods.put( KW_FIT_LCOL, ATTR_LOGICAL );
attrsAndMethods.put( KW_FIRST_PR, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_QR, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_SR, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_SS, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_SO, ATTR_HANDLE );
attrsAndMethods.put( KW_FIRST_TI, ATTR_HANDLE );
attrsAndMethods.put( KW_FIX_C_L , METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FLAT_BUT, ATTR_LOGICAL );
attrsAndMethods.put( KW_FLTR_MAP, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FNT_BOLD, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FNT_ITAL, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FNT_NAME, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FNT_SIZE, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FNT_UNDL, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FOC_ASEL, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FOC_NKEY, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FOC_NODE, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FOCUS_R , ATTR_INT );
attrsAndMethods.put( KW_FOCUS_RS, ATTR_LOGICAL );
attrsAndMethods.put( KW_FONT , ATTR_INT );
attrsAndMethods.put( KW_FORE , ATTR_LOGICAL );
attrsAndMethods.put( KW_F_KEY_H , ATTR_LOGICAL );
attrsAndMethods.put( KW_DB_JOIN , ATTR_LOGICAL );
attrsAndMethods.put( KW_FORM_INP, ATTR_CHAR );
attrsAndMethods.put( KW_FORM_LIN, ATTR_MEMPTR );
attrsAndMethods.put( KW_FORMAT , ATTR_CHAR );
attrsAndMethods.put( KW_FORMATTE, ATTR_LOGICAL );
attrsAndMethods.put( KW_FRAGMENT, ATTR_LOGICAL );
attrsAndMethods.put( KW_FRAME , ATTR_HANDLE );
attrsAndMethods.put( KW_FR_COL , ATTR_DEC );
attrsAndMethods.put( KW_FR_NAME , ATTR_CHAR );
attrsAndMethods.put( KW_FR_ROW , ATTR_DEC );
attrsAndMethods.put( KW_FR_SPACE, ATTR_INT );
attrsAndMethods.put( KW_FR_X , ATTR_INT );
attrsAndMethods.put( KW_FR_Y , ATTR_INT );
attrsAndMethods.put( KW_FREQ , ATTR_INT );
attrsAndMethods.put( KW_FS_NKEY , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FS_NODE , ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FULL_H_C, ATTR_DEC );
attrsAndMethods.put( KW_FULL_H_P, ATTR_INT );
attrsAndMethods.put( KW_FULL_W_C, ATTR_DEC );
attrsAndMethods.put( KW_FULL_W_P, ATTR_INT );
attrsAndMethods.put( KW_FULLPATH, ATTR_CHAR );
attrsAndMethods.put( KW_FUNCT , ATTR_CHAR );
attrsAndMethods.put( KW_FV_NODE , ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_FWD_LOGF, ATTR_CHAR ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_FWD_ONLY, ATTR_LOGICAL );
attrsAndMethods.put( KW_G_C_BGCO, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_G_C_FGCO, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_G_COL_P , METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_G_COL_W , METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_ATTL, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_ATTR, METH_CHAR ); // the 4GL docs say this should return LOGICAL, but that is not actually correct
attrsAndMethods.put( KW_GET_A_N , METH_LOGICAL );
attrsAndMethods.put( KW_GET_BCCL, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_BDAT, METH_MEMPTR );
attrsAndMethods.put( KW_GET_BLUE, METH_INT );
attrsAndMethods.put( KW_GET_BR_C, METH_HANDLE );
attrsAndMethods.put( KW_GET_BUFH, METH_HANDLE );
attrsAndMethods.put( KW_GET_B_A , ATTR_INT );
attrsAndMethods.put( KW_GET_C_S , METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_CBPC, METH_HANDLE );
attrsAndMethods.put( KW_GET_CBPN, METH_CHAR );
attrsAndMethods.put( KW_GET_CC_L, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_CFGV, METH_CHAR );
attrsAndMethods.put( KW_GET_CGIL, METH_CHAR );
attrsAndMethods.put( KW_GET_CGIV, METH_CHAR );
attrsAndMethods.put( KW_GET_CGLV, METH_LONGCHAR);
attrsAndMethods.put( KW_GET_CHG , METH_LOGICAL );
attrsAndMethods.put( KW_GET_CHLD, METH_LOGICAL );
attrsAndMethods.put( KW_GET_CLNT, METH_HANDLE );
attrsAndMethods.put( KW_GET_CREL, METH_HANDLE );
attrsAndMethods.put( KW_GET_CUR , METH_LOGICAL );
attrsAndMethods.put( KW_GET_D_E , METH_LOGICAL );
attrsAndMethods.put( KW_GET_D_F , METH_CHAR );
attrsAndMethods.put( KW_GET_DS_B, METH_HANDLE );
attrsAndMethods.put( KW_GET_DYN , METH_LOGICAL );
attrsAndMethods.put( KW_GET_EMBL, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_ERRC, METH_INT );
attrsAndMethods.put( KW_GET_ERRR, METH_INT );
attrsAndMethods.put( KW_GET_FCN , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_FNAM, METH_CHAR );
attrsAndMethods.put( KW_GET_FOFF, METH_INT );
attrsAndMethods.put( KW_GET_1ST , METH_LOGICAL );
attrsAndMethods.put( KW_GET_GRN , METH_INT );
attrsAndMethods.put( KW_GET_HD_E, METH_LOGICAL );
attrsAndMethods.put( KW_GET_IBNN, METH_INT );
attrsAndMethods.put( KW_GET_IBQN, METH_INT );
attrsAndMethods.put( KW_GET_ITER, METH_HANDLE );
attrsAndMethods.put( KW_GET_LAST, METH_LOGICAL );
attrsAndMethods.put( KW_GET_LNBI, METH_CHAR );
attrsAndMethods.put( KW_GET_LPRM, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_MOP , METH_POLY ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_GET_MSG , METH_CHAR );
attrsAndMethods.put( KW_GET_N_AT, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_N_BG, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_N_FG, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_N_HC, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_N_N , METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_NEXT, METH_LOGICAL );
attrsAndMethods.put( KW_GET_NLEV, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_NODE, METH_LOGICAL );
attrsAndMethods.put( KW_GET_NSN , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_NTXT, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_NUM , METH_INT );
attrsAndMethods.put( KW_GET_NVV, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_PAR , METH_LOGICAL );
attrsAndMethods.put( KW_GET_PARN, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_PREV, METH_LOGICAL );
attrsAndMethods.put( KW_GET_PROP, METH_CHAR );
attrsAndMethods.put( KW_GET_PRT , METH_CHAR );
attrsAndMethods.put( KW_GET_PSN , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_QNBI, METH_CHAR );
attrsAndMethods.put( KW_GET_RED , METH_INT );
attrsAndMethods.put( KW_GET_REL , METH_HANDLE );
attrsAndMethods.put( KW_GET_R_R , METH_INT );
attrsAndMethods.put( KW_GET_RGB , METH_INT );
attrsAndMethods.put( KW_GET_SELW, METH_HANDLE );
attrsAndMethods.put( KW_GET_SER , METH_LONGCHAR);
attrsAndMethods.put( KW_GET_SIG , METH_CHAR );
attrsAndMethods.put( KW_GET_SIMG, METH_MEMPTR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_S_O , METH_CHAR );
attrsAndMethods.put( KW_GET_SNC , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_SRCB, ATTR_HANDLE );
attrsAndMethods.put( KW_GET_TBI , METH_CHAR );
attrsAndMethods.put( KW_GET_TBNN, METH_CHAR );
attrsAndMethods.put( KW_GET_TBQN, METH_CHAR );
attrsAndMethods.put( KW_GET_TI , METH_HANDLE );
attrsAndMethods.put( KW_GET_THCH, METH_DEC );
attrsAndMethods.put( KW_GET_THPX, METH_INT );
attrsAndMethods.put( KW_GET_TNOD, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_TO_L, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_GET_TOPB, METH_HANDLE );
attrsAndMethods.put( KW_GET_TWCH, METH_DEC );
attrsAndMethods.put( KW_GET_TWPX, METH_INT );
attrsAndMethods.put( KW_GET_UBI , METH_CHAR );
attrsAndMethods.put( KW_GET_VBI , METH_CHAR );
attrsAndMethods.put( KW_GET_VBNN, METH_CHAR );
attrsAndMethods.put( KW_GET_VBQN, METH_CHAR );
attrsAndMethods.put( KW_GET_WAIT, METH_CHAR );
attrsAndMethods.put( KW_GRAPHIC , ATTR_LOGICAL );
attrsAndMethods.put( KW_GRD_F_H , ATTR_INT );
attrsAndMethods.put( KW_GRD_F_V , ATTR_INT );
attrsAndMethods.put( KW_GRD_SNAP, ATTR_LOGICAL );
attrsAndMethods.put( KW_GRD_UHC , ATTR_DEC );
attrsAndMethods.put( KW_GRD_UHP , ATTR_INT );
attrsAndMethods.put( KW_GRD_UWC , ATTR_DEC );
attrsAndMethods.put( KW_GRD_UWP , ATTR_INT );
attrsAndMethods.put( KW_GRD_VIS , ATTR_LOGICAL );
attrsAndMethods.put( KW_GROUP_BX, ATTR_LOGICAL );
attrsAndMethods.put( KW_H_SCRL_P, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_HIT_TEST, METH_COM_HANDLE); // FWD extension, not real 4GL
attrsAndMethods.put( KW_HIT_TFWD, METH_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_HANDLE , ATTR_HANDLE );
attrsAndMethods.put( KW_HANDLER , ATTR_HANDLE );
attrsAndMethods.put( KW_HAS_LOBS, ATTR_LOGICAL );
attrsAndMethods.put( KW_HAS_REC , ATTR_LOGICAL );
attrsAndMethods.put( KW_HEIGHT_C, ATTR_DEC );
attrsAndMethods.put( KW_HEIGHT_P, ATTR_INT );
attrsAndMethods.put( KW_HELP , ATTR_CHAR );
attrsAndMethods.put( KW_HIDDEN , ATTR_LOGICAL );
attrsAndMethods.put( KW_HORIZ , ATTR_LOGICAL );
attrsAndMethods.put( KW_HTML_CHS, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_EOL, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_EOP, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_FRB, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_FRE, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_H_B, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_H_E, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_T_B, ATTR_CHAR );
attrsAndMethods.put( KW_HTML_T_E, ATTR_CHAR );
attrsAndMethods.put( KW_HWND , ATTR_INT );
attrsAndMethods.put( KW_HYPERLNK, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_ICON , ATTR_CHAR );
attrsAndMethods.put( KW_ICFPARM , ATTR_CHAR );
attrsAndMethods.put( KW_IDEPHWND, ATTR_INT ); // undocumented, found in customer code as INT (not HANDLE)
attrsAndMethods.put( KW_IDEWNTYP, ATTR_INT ); // undocumented
attrsAndMethods.put( KW_IGN_CMOD, ATTR_LOGICAL );
attrsAndMethods.put( KW_IMAGE , ATTR_CHAR );
attrsAndMethods.put( KW_IMG_DOWN, ATTR_CHAR );
attrsAndMethods.put( KW_IMG_INS , ATTR_CHAR );
attrsAndMethods.put( KW_IMG_LIST, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IMG_ONLY, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_BGCOL, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_HEIGH, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_WIDTH, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_LIST , ATTR_COM_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_MASK , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_OVER , ATTR_COM_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IL_UMASK, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IMG_UP , ATTR_CHAR );
attrsAndMethods.put( KW_IMM_DISP, ATTR_LOGICAL );
attrsAndMethods.put( KW_IMP_NODE, METH_LOGICAL );
attrsAndMethods.put( KW_IMP_PRNC, METH_LOGICAL );
attrsAndMethods.put( KW_IDX_INFO, ATTR_CHAR );
attrsAndMethods.put( KW_IN_HNDL , ATTR_HANDLE );
attrsAndMethods.put( KW_INC_EX_I, METH_INT );
attrsAndMethods.put( KW_INDENT, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_INDEX , ATTR_INT );
attrsAndMethods.put( KW_INH_BGC , ATTR_LOGICAL );
attrsAndMethods.put( KW_INH_FGC , ATTR_LOGICAL );
attrsAndMethods.put( KW_INIT , ATTR_CHAR );
attrsAndMethods.put( KW_INIT_C_P, METH_LOGICAL );
attrsAndMethods.put( KW_INIT_D_T, METH_LOGICAL );
attrsAndMethods.put( KW_INITIATE, METH_LOGICAL );
attrsAndMethods.put( KW_INNER_C , ATTR_INT );
attrsAndMethods.put( KW_INNER_L , ATTR_INT );
attrsAndMethods.put( KW_INPT_VAL, ATTR_POLY );
attrsAndMethods.put( KW_INS_ATTR, METH_LOGICAL );
attrsAndMethods.put( KW_INS_B4 , METH_LOGICAL );
attrsAndMethods.put( KW_INS_BTAB, METH_LOGICAL );
attrsAndMethods.put( KW_INS_FILE, METH_LOGICAL );
attrsAndMethods.put( KW_INS_ROW , METH_LOGICAL );
attrsAndMethods.put( KW_INS_STR , METH_LOGICAL );
attrsAndMethods.put( KW_INS_TAB , METH_LOGICAL );
attrsAndMethods.put( KW_INSERT , METH_LOGICAL );
attrsAndMethods.put( KW_INST_PRC, ATTR_HANDLE );
attrsAndMethods.put( KW_INT_ENT , ATTR_CHAR );
attrsAndMethods.put( KW_INTERVAL, ATTR_INT64 ); // FWD TIMER extension
attrsAndMethods.put( KW_INVOKE , METH_VOID );
attrsAndMethods.put( KW_IP_TIME , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IS_C_VIS, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IS_CLASS, ATTR_LOGICAL );
attrsAndMethods.put( KW_IS_DB_MT, FUNC_LOGICAL ); // latest language reference includes this
attrsAndMethods.put( KW_IS_JSON , ATTR_LOGICAL );
attrsAndMethods.put( KW_IS_M_TEN, ATTR_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_IS_MSEL, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IS_N_EXP, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_IS_OPEN , ATTR_LOGICAL );
attrsAndMethods.put( KW_IS_PART , ATTR_LOGICAL );
attrsAndMethods.put( KW_IS_P_SET, ATTR_LOGICAL );
attrsAndMethods.put( KW_IS_R_SEL, METH_LOGICAL );
attrsAndMethods.put( KW_IS_SEL , METH_LOGICAL );
attrsAndMethods.put( KW_IS_XML , ATTR_LOGICAL );
attrsAndMethods.put( KW_ITEM_ROW, ATTR_INT );
attrsAndMethods.put( KW_KEEP_CON, ATTR_LOGICAL );
attrsAndMethods.put( KW_KEEP_ZOR, ATTR_LOGICAL );
attrsAndMethods.put( KW_KEEP_SEC, ATTR_LOGICAL );
attrsAndMethods.put( KW_KEY , ATTR_LOGICAL );
attrsAndMethods.put( KW_KEYS , ATTR_CHAR );
attrsAndMethods.put( KW_KPAD_HOT, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_KPAD_CLE, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_KPAD_QRY, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_LABEL , ATTR_CHAR );
attrsAndMethods.put( KW_LAB_BGC , ATTR_INT );
attrsAndMethods.put( KW_LAB_DC , ATTR_INT );
attrsAndMethods.put( KW_LAB_FGC , ATTR_INT );
attrsAndMethods.put( KW_LAB_FONT, ATTR_INT );
attrsAndMethods.put( KW_LABELS , ATTR_LOGICAL );
attrsAndMethods.put( KW_LAB_H_C , ATTR_LOGICAL );
attrsAndMethods.put( KW_LANGUAGE, ATTR_CHAR );
attrsAndMethods.put( KW_LARGE , ATTR_LOGICAL );
attrsAndMethods.put( KW_LAST_AR , ATTR_HANDLE );
attrsAndMethods.put( KW_LAST_BAT, ATTR_LOGICAL );
attrsAndMethods.put( KW_LAST_CH , ATTR_HANDLE );
attrsAndMethods.put( KW_LAST_FRM, ATTR_CLASS );
attrsAndMethods.put( KW_LAST_OBJ, ATTR_CLASS );
attrsAndMethods.put( KW_LAST_OF , METH_LOGICAL );
attrsAndMethods.put( KW_LAST_PRC, ATTR_HANDLE );
attrsAndMethods.put( KW_LAST_SRV, ATTR_HANDLE );
attrsAndMethods.put( KW_LAST_SS , ATTR_HANDLE );
attrsAndMethods.put( KW_LAST_SOC, ATTR_HANDLE );
attrsAndMethods.put( KW_LAST_TI , ATTR_HANDLE );
attrsAndMethods.put( KW_LCD_REFR, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_LCD_SWIN, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_LCD_WSTR, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_LCHR_2NV, METH_LOGICAL );
attrsAndMethods.put( KW_LENGTH , ATTR_INT );
attrsAndMethods.put( KW_LG_2_SM , ATTR_LOGICAL );
attrsAndMethods.put( KW_LIB , ATTR_CHAR );
attrsAndMethods.put( KW_LIB_C_C , ATTR_CHAR );
attrsAndMethods.put( KW_LINE , ATTR_INT );
attrsAndMethods.put( KW_LISTINGS, ATTR_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_LIST_PNM, METH_CHAR );
attrsAndMethods.put( KW_LIT_QSTN, ATTR_LOGICAL );
attrsAndMethods.put( KW_LOAD , METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_DMN, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_ICO, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_IMG, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_I_D, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_I_I, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_I_U, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_M_P, METH_LOGICAL );
attrsAndMethods.put( KW_LOAD_S_I, METH_LOGICAL );
attrsAndMethods.put( KW_LOC_V_I , ATTR_CLASS );
attrsAndMethods.put( KW_LOC_C_N , ATTR_INT );
attrsAndMethods.put( KW_LOC_HOST, ATTR_CHAR );
attrsAndMethods.put( KW_LOC_L_N , ATTR_INT );
attrsAndMethods.put( KW_LOC_NAME, ATTR_CHAR );
attrsAndMethods.put( KW_LOC_PORT, ATTR_INT );
attrsAndMethods.put( KW_LOC_P_ID, ATTR_CHAR );
attrsAndMethods.put( KW_LOC_S_ID, ATTR_CHAR );
attrsAndMethods.put( KW_LOC_TYPE, ATTR_CHAR );
attrsAndMethods.put( KW_LOCKED , ATTR_LOGICAL );
attrsAndMethods.put( KW_LOCK_REG, METH_LOGICAL );
attrsAndMethods.put( KW_LOOKUP , METH_INT );
attrsAndMethods.put( KW_LOG_A_EV, METH_CHAR );
attrsAndMethods.put( KW_LOG_E_TS, ATTR_DATETIME_TZ );
attrsAndMethods.put( KW_LOG_EN_T, ATTR_CHAR );
attrsAndMethods.put( KW_LOG_ID , ATTR_INT );
attrsAndMethods.put( KW_LOG_HOST, ATTR_CHAR );
attrsAndMethods.put( KW_LOG_STAT, ATTR_CHAR );
attrsAndMethods.put( KW_LOG_THRS, ATTR_INT );
attrsAndMethods.put( KW_LOGF_NAM, ATTR_CHAR );
attrsAndMethods.put( KW_LOGG_LEV, ATTR_INT );
attrsAndMethods.put( KW_LOGOUT , METH_LOGICAL );
attrsAndMethods.put( KW_LST_PAIR, ATTR_CHAR );
attrsAndMethods.put( KW_LIST_ITM, ATTR_CHAR );
attrsAndMethods.put( KW_M_D_I_P, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_M_U_I_P, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_MAND , ATTR_LOGICAL );
attrsAndMethods.put( KW_MAN_HIGH, ATTR_LOGICAL );
attrsAndMethods.put( KW_MARG_H_C, ATTR_DEC ); // undocumented attributes found in customer source code
attrsAndMethods.put( KW_MARG_H_P, ATTR_INT ); // undocumented attributes found in customer source code
attrsAndMethods.put( KW_MARG_W_C, ATTR_DEC ); // undocumented attributes found in customer source code
attrsAndMethods.put( KW_MARG_W_P, ATTR_INT ); // undocumented attributes found in customer source code
attrsAndMethods.put( KW_MARK_NEW, METH_LOGICAL );
attrsAndMethods.put( KW_MARK_RS , METH_LOGICAL );
attrsAndMethods.put( KW_MAX_BTN , ATTR_LOGICAL );
attrsAndMethods.put( KW_MAX_CHAR, ATTR_INT );
attrsAndMethods.put( KW_MAX_D_G , ATTR_INT );
attrsAndMethods.put( KW_MAX_HT , ATTR_DEC );
attrsAndMethods.put( KW_MAX_H_C , ATTR_DEC );
attrsAndMethods.put( KW_MAX_H_P , ATTR_INT );
attrsAndMethods.put( KW_MAX_LVL , ATTR_INT );
attrsAndMethods.put( KW_MAX_VAL , ATTR_INT );
attrsAndMethods.put( KW_MAX_WID , ATTR_INT );
attrsAndMethods.put( KW_MAX_W_C , ATTR_DEC );
attrsAndMethods.put( KW_MAX_W_P , ATTR_INT );
attrsAndMethods.put( KW_MD5_VAL , ATTR_CHAR );
attrsAndMethods.put( KW_MPTR_2NV, METH_LOGICAL );
attrsAndMethods.put( KW_MENU_BAR, ATTR_HANDLE );
attrsAndMethods.put( KW_MENU_KEY, ATTR_CHAR );
attrsAndMethods.put( KW_MENU_MOU, ATTR_INT );
attrsAndMethods.put( KW_MERGE_BF, ATTR_LOGICAL );
attrsAndMethods.put( KW_MERGE_CH, METH_LOGICAL );
attrsAndMethods.put( KW_MERGE_RC, METH_LOGICAL );
attrsAndMethods.put( KW_MIN_BTN , ATTR_LOGICAL );
attrsAndMethods.put( KW_MIN_CWCH, ATTR_DEC );
attrsAndMethods.put( KW_MIN_CWPX, ATTR_INT );
attrsAndMethods.put( KW_MIN_H_C , ATTR_DEC );
attrsAndMethods.put( KW_MIN_H_P , ATTR_INT );
attrsAndMethods.put( KW_MIN_SCHM, ATTR_LOGICAL );
attrsAndMethods.put( KW_MIN_VAL , ATTR_INT );
attrsAndMethods.put( KW_MIN_W_C , ATTR_DEC );
attrsAndMethods.put( KW_MIN_W_P , ATTR_INT );
attrsAndMethods.put( KW_MSICON, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_MODIFIRS, ATTR_INT ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_MSG_AREA, ATTR_LOGICAL );
attrsAndMethods.put( KW_MSG_AFNT, ATTR_INT );
attrsAndMethods.put( KW_MSG_AMSG, METH_CHAR ); // undocumented SESSION method
attrsAndMethods.put( KW_MSPNTNUM, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_MNEMON, ATTR_INT ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_MODIFIED, ATTR_LOGICAL );
attrsAndMethods.put( KW_MOU_PTR , ATTR_CHAR );
attrsAndMethods.put( KW_MOVABLE , ATTR_LOGICAL );
attrsAndMethods.put( KW_MOV_A_T , METH_LOGICAL );
attrsAndMethods.put( KW_MOV_B_T , METH_LOGICAL );
attrsAndMethods.put( KW_MOV_COL , METH_LOGICAL );
attrsAndMethods.put( KW_MOV_2_B , METH_LOGICAL );
attrsAndMethods.put( KW_MOV_2_T , METH_LOGICAL );
attrsAndMethods.put( KW_MOV_2EOF, METH_LOGICAL );
attrsAndMethods.put( KW_MULT_CMP, ATTR_LOGICAL );
attrsAndMethods.put( KW_MULTIPLE, ATTR_LOGICAL );
attrsAndMethods.put( KW_MULTI_IN, ATTR_INT );
attrsAndMethods.put( KW_MUST_UND, ATTR_LOGICAL );
attrsAndMethods.put( KW_OWN_DOC , ATTR_HANDLE );
attrsAndMethods.put( KW_OVERLAY , ATTR_LOGICAL );
attrsAndMethods.put( KW_NAME , ATTR_CHAR );
attrsAndMethods.put( KW_NAMESP_P, ATTR_CHAR );
attrsAndMethods.put( KW_NAMESP_U, ATTR_CHAR );
attrsAndMethods.put( KW_NEEDS_AP, ATTR_LOGICAL );
attrsAndMethods.put( KW_NEEDS_PR, ATTR_LOGICAL );
attrsAndMethods.put( KW_NESTED , ATTR_LOGICAL );
attrsAndMethods.put( KW_NEW , ATTR_LOGICAL );
attrsAndMethods.put( KW_NEW_ROW , ATTR_LOGICAL );
attrsAndMethods.put( KW_NEW_SESS, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NEXT_COL, ATTR_HANDLE );
attrsAndMethods.put( KW_NEXT_RID, ATTR_ROWID );
attrsAndMethods.put( KW_NEXT_SIB, ATTR_HANDLE );
attrsAndMethods.put( KW_NEXT_TAB, ATTR_HANDLE );
attrsAndMethods.put( KW_NNMSP_SL, ATTR_CHAR );
attrsAndMethods.put( KW_N_HEIGHT, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_N_KEY_ID, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NO_COLS, ATTR_LOGICAL );
attrsAndMethods.put( KW_NO_FOCUS, ATTR_LOGICAL );
attrsAndMethods.put( KW_NO_CUR_V, ATTR_LOGICAL );
attrsAndMethods.put( KW_NO_EM_SP, ATTR_LOGICAL );
attrsAndMethods.put( KW_NO_SCH_M, ATTR_LOGICAL );
attrsAndMethods.put( KW_NO_VALID, ATTR_LOGICAL );
attrsAndMethods.put( KW_NODE_BLD, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_CNT, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_EXP, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_ICO, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_ID , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_IDX, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_KEY, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_PAR, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_TXT, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NODE_VAL, ATTR_CHAR );
attrsAndMethods.put( KW_NODE_V2M, METH_LOGICAL );
attrsAndMethods.put( KW_NODV_2LC, METH_LOGICAL );
attrsAndMethods.put( KW_NORMALZE, METH_LOGICAL );
attrsAndMethods.put( KW_NUM_BUFF, ATTR_INT );
attrsAndMethods.put( KW_NUM_BUTT, ATTR_INT );
attrsAndMethods.put( KW_NUM_CH_R, ATTR_INT );
attrsAndMethods.put( KW_NUM_DROP, ATTR_INT );
attrsAndMethods.put( KW_NUM_ENT , ATTR_INT );
attrsAndMethods.put( KW_NUM_FLD , ATTR_INT );
attrsAndMethods.put( KW_NUM_FMTS, ATTR_INT );
attrsAndMethods.put( KW_NUM_HD_E, ATTR_INT );
attrsAndMethods.put( KW_NUM_ITMS, ATTR_INT );
attrsAndMethods.put( KW_NUM_ITER, ATTR_INT );
attrsAndMethods.put( KW_NUM_LK_C, ATTR_INT );
attrsAndMethods.put( KW_NUM_LNS, ATTR_INT );
attrsAndMethods.put( KW_NUM_LOGF, ATTR_INT );
attrsAndMethods.put( KW_NUM_MSG , ATTR_INT );
attrsAndMethods.put( KW_NUM_PNTS, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_NUM_CHLN, ATTR_INT );
attrsAndMethods.put( KW_NUM_COL , ATTR_INT );
attrsAndMethods.put( KW_NUM_PARM, ATTR_INT );
attrsAndMethods.put( KW_NUM_REF , ATTR_INT );
attrsAndMethods.put( KW_NUM_REL , ATTR_INT );
attrsAndMethods.put( KW_NUM_REPL, ATTR_INT );
attrsAndMethods.put( KW_NUM_RES , ATTR_INT );
attrsAndMethods.put( KW_NUM_SR , ATTR_INT );
attrsAndMethods.put( KW_NUM_SW , ATTR_INT );
attrsAndMethods.put( KW_NUM_TABS, ATTR_INT );
attrsAndMethods.put( KW_NUM_2RTN, ATTR_INT );
attrsAndMethods.put( KW_NUM_V_C , ATTR_INT );
attrsAndMethods.put( KW_NUM_D_P , ATTR_CHAR );
attrsAndMethods.put( KW_NUM_FMT , ATTR_CHAR );
attrsAndMethods.put( KW_NUM_SEP , ATTR_CHAR );
attrsAndMethods.put( KW_NUM_SRCB, ATTR_INT );
attrsAndMethods.put( KW_NUM_TOPB, ATTR_INT );
attrsAndMethods.put( KW_OPENHTML, METH_VOID ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_OPENPAGE, METH_LOGICAL ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_OLE_INVL, ATTR_INT );
attrsAndMethods.put( KW_OLE_NAML, ATTR_INT );
attrsAndMethods.put( KW_ON_FR_B , ATTR_LOGICAL );
attrsAndMethods.put( KW_ORDINAL, ATTR_INT );
attrsAndMethods.put( KW_ORG_HAND, ATTR_HANDLE );
attrsAndMethods.put( KW_ORG_ROID, ATTR_ROWID );
attrsAndMethods.put( KW_OWNER , ATTR_HANDLE );
attrsAndMethods.put( KW_PAGE_B , ATTR_LOGICAL );
attrsAndMethods.put( KW_PAGE_T , ATTR_LOGICAL );
attrsAndMethods.put( KW_PAR_BUFF, ATTR_HANDLE );
attrsAndMethods.put( KW_PAR_IREL, ATTR_LOGICAL );
attrsAndMethods.put( KW_PAR_REL , ATTR_HANDLE );
attrsAndMethods.put( KW_PARENT , ATTR_HANDLE );
attrsAndMethods.put( KW_PARM , ATTR_CHAR );
attrsAndMethods.put( KW_PARSE_ST, ATTR_INT );
attrsAndMethods.put( KW_PAR_FLDA, ATTR_CHAR );
attrsAndMethods.put( KW_PAR_FLDB, ATTR_CHAR );
attrsAndMethods.put( KW_PASSWD_F, ATTR_LOGICAL );
attrsAndMethods.put( KW_PATHNAME, ATTR_CHAR );
attrsAndMethods.put( KW_PBE_H_AL, ATTR_CHAR );
attrsAndMethods.put( KW_PBE_KEYR, ATTR_INT );
attrsAndMethods.put( KW_POSTMSG, METH_VOID ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_OCX_MBTN, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_OCX_MSHT, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_OCX_MSX, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_OCX_MSY, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_OLE_AEFF, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_DATF, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_DEFC, ATTR_LOGICAL ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_EFFE, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_DRAG, METH_VOID ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_DGMD, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_DRMD, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_STAT, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_X, ATTR_DEC ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_OLE_Y, ATTR_DEC ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_DRAG_NOD, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_DRAG_OVR, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_OPENPOPU, METH_VOID ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_APPEA, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_BRSTY, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_COM_DATA, ATTR_HANDLE ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_ENABL, ATTR_LOGICAL ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_MAX, ATTR_DEC ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_MIN, ATTR_DEC ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_ORIEN, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_SCROL, ATTR_INT ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PB_VALUE, ATTR_DEC ); // FWD PROGRESS-BAR extension, not real 4GL
attrsAndMethods.put( KW_PREF_DS , ATTR_LOGICAL );
attrsAndMethods.put( KW_PRS_PROC, ATTR_HANDLE );
attrsAndMethods.put( KW_PRS_C_D , ATTR_LOGICAL );
attrsAndMethods.put( KW_PERSIST , ATTR_LOGICAL );
attrsAndMethods.put( KW_PFCOLOR , ATTR_INT );
attrsAndMethods.put( KW_PIX_COL , ATTR_INT );
attrsAndMethods.put( KW_PIX_ROW , ATTR_INT );
attrsAndMethods.put( KW_POP_MENU, ATTR_HANDLE );
attrsAndMethods.put( KW_POP_ONLY, ATTR_LOGICAL );
attrsAndMethods.put( KW_POS , ATTR_INT );
attrsAndMethods.put( KW_PREP_STR, ATTR_CHAR );
attrsAndMethods.put( KW_PREPARED, ATTR_LOGICAL );
attrsAndMethods.put( KW_PREV_COL, ATTR_HANDLE );
attrsAndMethods.put( KW_PREV_SIB, ATTR_HANDLE );
attrsAndMethods.put( KW_PREV_T_I, ATTR_HANDLE );
attrsAndMethods.put( KW_PRE_LBL, ATTR_CHAR ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_PRIM_P_P, ATTR_CHAR );
attrsAndMethods.put( KW_PRIMARY , ATTR_CHAR );
attrsAndMethods.put( KW_PRINT , METH_VOID ); // FWD extension, not real 4GL!
attrsAndMethods.put( KW_PROFILNG, ATTR_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_PROG_SRC, ATTR_LOGICAL );
attrsAndMethods.put( KW_PRT_C_H , ATTR_INT );
attrsAndMethods.put( KW_PRT_HDC , ATTR_INT );
attrsAndMethods.put( KW_PRT_NAME, ATTR_CHAR );
attrsAndMethods.put( KW_PRT_PORT, ATTR_CHAR );
attrsAndMethods.put( KW_PRIV_DAT, ATTR_CHAR );
attrsAndMethods.put( KW_PROCNAME, ATTR_CHAR );
attrsAndMethods.put( KW_PROCTYPE, ATTR_CHAR );
attrsAndMethods.put( KW_PROXY , ATTR_LOGICAL );
attrsAndMethods.put( KW_PROX_PWD, ATTR_CHAR );
attrsAndMethods.put( KW_PROX_UID, ATTR_CHAR );
attrsAndMethods.put( KW_PUB_ID , ATTR_CHAR );
attrsAndMethods.put( KW_PUB_EVTS, ATTR_CHAR );
attrsAndMethods.put( KW_QUAL_UID, ATTR_CHAR );
attrsAndMethods.put( KW_QUERY , ATTR_HANDLE );
attrsAndMethods.put( KW_QRY_CLOS, METH_LOGICAL );
attrsAndMethods.put( KW_QRY_OFF , ATTR_LOGICAL );
attrsAndMethods.put( KW_QRY_OPEN, METH_LOGICAL );
attrsAndMethods.put( KW_QRY_PREP, METH_LOGICAL );
attrsAndMethods.put( KW_QUIT , ATTR_LOGICAL );
attrsAndMethods.put( KW_RADIO_B , ATTR_CHAR );
attrsAndMethods.put( KW_RAW_TRAN, METH_LOGICAL );
attrsAndMethods.put( KW_READ , METH_LOGICAL );
attrsAndMethods.put( KW_READ_FIL, METH_LOGICAL );
attrsAndMethods.put( KW_READ_JSN, METH_LOGICAL );
attrsAndMethods.put( KW_READ_ONL, ATTR_LOGICAL );
attrsAndMethods.put( KW_READ_XML, METH_LOGICAL );
attrsAndMethods.put( KW_READ_XSC, METH_LOGICAL );
attrsAndMethods.put( KW_RECID , ATTR_RECID );
attrsAndMethods.put( KW_REC_LEN , ATTR_INT );
attrsAndMethods.put( KW_RECURSE , ATTR_LOGICAL );
attrsAndMethods.put( KW_REFRESH , METH_LOGICAL );
attrsAndMethods.put( KW_REFR_A_P, METH_LOGICAL );
attrsAndMethods.put( KW_REFRABLE, ATTR_LOGICAL );
attrsAndMethods.put( KW_REG_DMN , METH_LOGICAL );
attrsAndMethods.put( KW_REJ_CHGS, METH_LOGICAL );
attrsAndMethods.put( KW_REJ_RCHG, METH_LOGICAL );
attrsAndMethods.put( KW_REJECTED, ATTR_LOGICAL );
attrsAndMethods.put( KW_REL_FLDS, ATTR_CHAR );
attrsAndMethods.put( KW_RELS_ACT, ATTR_LOGICAL );
attrsAndMethods.put( KW_RELSESID, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_REM_EVTP, METH_LOGICAL );
attrsAndMethods.put( KW_REM_HOST, ATTR_CHAR );
attrsAndMethods.put( KW_REM_PORT, ATTR_INT );
attrsAndMethods.put( KW_REMOTE , ATTR_LOGICAL );
attrsAndMethods.put( KW_REM_NOCO, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_REM_NODE, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_REM_ATTR, METH_LOGICAL );
attrsAndMethods.put( KW_REM_CHLD, METH_LOGICAL );
attrsAndMethods.put( KW_REM_SUP , METH_LOGICAL );
attrsAndMethods.put( KW_REPLACE , METH_LOGICAL );
attrsAndMethods.put( KW_REP_CHLD, METH_LOGICAL );
attrsAndMethods.put( KW_REP_STXT, METH_LOGICAL );
attrsAndMethods.put( KW_REPORT, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_REPOS , ATTR_LOGICAL );
attrsAndMethods.put( KW_REPOS_B , METH_LOGICAL );
attrsAndMethods.put( KW_REPOS_F , METH_LOGICAL );
attrsAndMethods.put( KW_REPOS_2R, METH_LOGICAL );
attrsAndMethods.put( KW_REPOS_2I, METH_LOGICAL );
attrsAndMethods.put( KW_REQ_INFO, ATTR_CLASS );
attrsAndMethods.put( KW_RFRSH_UI, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RSP_INFO, ATTR_CLASS );
attrsAndMethods.put( KW_RES_BASE, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RESET , METH_LOGICAL );
attrsAndMethods.put( KW_RESIZE , ATTR_LOGICAL );
attrsAndMethods.put( KW_RESIZABL, ATTR_LOGICAL );
attrsAndMethods.put( KW_RESORT , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_REST_RID, ATTR_ROWID );
attrsAndMethods.put( KW_REST_ROW, ATTR_INT );
attrsAndMethods.put( KW_RET_INS , ATTR_LOGICAL );
attrsAndMethods.put( KW_RET_SHAP, ATTR_LOGICAL );
attrsAndMethods.put( KW_RET_VAL , ATTR_POLY );
attrsAndMethods.put( KW_RET_VDT , ATTR_CHAR );
attrsAndMethods.put( KW_RET_VLT , ATTR_CHAR );
attrsAndMethods.put( KW_ROLE , ATTR_CHAR );
attrsAndMethods.put( KW_ROLES , ATTR_CHAR );
attrsAndMethods.put( KW_ROUNDED , ATTR_LOGICAL );
attrsAndMethods.put( KW_ROW , ATTR_DEC );
attrsAndMethods.put( KW_ROW_H_C , ATTR_DEC );
attrsAndMethods.put( KW_ROW_H_P , ATTR_INT );
attrsAndMethods.put( KW_ROWID , ATTR_ROWID );
attrsAndMethods.put( KW_ROW_MARK, ATTR_LOGICAL );
attrsAndMethods.put( KW_ROW_RESZ, ATTR_LOGICAL );
attrsAndMethods.put( KW_ROW_STAT, ATTR_INT );
attrsAndMethods.put( KW_RPT_ADDC, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_CAP , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_DSGN, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_CSV , METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_DOCX, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_GSRC, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_GSRR, METH_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_HTML, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_ICSV, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_PDF , METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_RTF , METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_SRC, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_XLS , METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RPT_XLSX, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_RULE_ROW, ATTR_DEC ); // undocumented attribute seen in Possenet code (see adecomm/_report.p)
attrsAndMethods.put( KW_SCR_NODC , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SAVE , METH_LOGICAL );
attrsAndMethods.put( KW_SAVE_FIL, METH_LOGICAL );
attrsAndMethods.put( KW_SAVE_RCH, METH_LOGICAL );
attrsAndMethods.put( KW_SAVE_WST, ATTR_CHAR );
attrsAndMethods.put( KW_SAX_PARF, METH_VOID );
attrsAndMethods.put( KW_SAX_PARN, METH_VOID );
attrsAndMethods.put( KW_SAX_PARS, METH_VOID );
attrsAndMethods.put( KW_SCH_CHG , ATTR_CHAR );
attrsAndMethods.put( KW_SCH_LOC , ATTR_CHAR );
attrsAndMethods.put( KW_SCH_MARS, ATTR_CHAR );
attrsAndMethods.put( KW_SCH_PATH, ATTR_CHAR );
attrsAndMethods.put( KW_SCR_COL , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SCR_HGHT, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SCR_NTOP, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SCR_SCAL, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SCR_WDTH, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SCRN_VAL, ATTR_CHAR );
attrsAndMethods.put( KW_SCRN_LNS, ATTR_DEC );
attrsAndMethods.put( KW_SCROLLBA, ATTR_LOGICAL );
attrsAndMethods.put( KW_SCR_2CR , METH_LOGICAL );
attrsAndMethods.put( KW_SCR_2ITM, METH_LOGICAL );
attrsAndMethods.put( KW_SCR_2SR , METH_LOGICAL );
attrsAndMethods.put( KW_SCR_VERT, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SCROLLBL, ATTR_LOGICAL );
attrsAndMethods.put( KW_SCROLL_H, ATTR_LOGICAL );
attrsAndMethods.put( KW_SCROLL_V, ATTR_LOGICAL );
attrsAndMethods.put( KW_SEAL , METH_LOGICAL );
attrsAndMethods.put( KW_SEAL_TST, ATTR_DATETIME_TZ );
attrsAndMethods.put( KW_SEARCH , METH_LOGICAL );
attrsAndMethods.put( KW_SELECTBL, ATTR_LOGICAL );
attrsAndMethods.put( KW_SEL_ALL , METH_LOGICAL );
attrsAndMethods.put( KW_SEL_END , ATTR_INT );
attrsAndMethods.put( KW_SEL_FOCR, METH_LOGICAL );
attrsAndMethods.put( KW_SEL_NEXT, METH_LOGICAL );
attrsAndMethods.put( KW_SEL_PREV, METH_LOGICAL );
attrsAndMethods.put( KW_SEL_ROW , METH_LOGICAL );
attrsAndMethods.put( KW_SEL_STRT, ATTR_INT );
attrsAndMethods.put( KW_SEL_TXT , ATTR_CHAR );
attrsAndMethods.put( KW_SELECTED, ATTR_LOGICAL );
attrsAndMethods.put( KW_SEND , METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SENSITIV, ATTR_LOGICAL );
attrsAndMethods.put( KW_SEPS , ATTR_LOGICAL );
attrsAndMethods.put( KW_SEP_FGC , ATTR_INT );
attrsAndMethods.put( KW_SERIALZH, ATTR_LOGICAL );
attrsAndMethods.put( KW_SERIALZN, ATTR_CHAR );
attrsAndMethods.put( KW_SERIALZR, METH_LOGICAL );
attrsAndMethods.put( KW_SERVER , ATTR_HANDLE );
attrsAndMethods.put( KW_SESS_END, ATTR_LOGICAL );
attrsAndMethods.put( KW_SESSN_ID, ATTR_CHAR );
attrsAndMethods.put( KW_S_C_BGCO, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_S_C_FGCO, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_S_COL_C , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_S_COL_W , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SRV_C_B , ATTR_LOGICAL );
attrsAndMethods.put( KW_SRV_C_BR, ATTR_LOGICAL );
attrsAndMethods.put( KW_SRV_C_C , ATTR_CHAR );
attrsAndMethods.put( KW_SRV_C_I , ATTR_CHAR );
attrsAndMethods.put( KW_SRV_OP_M, ATTR_CHAR );
attrsAndMethods.put( KW_SCR_WLNS, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SEL_SFVN, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SEL_NID, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SEL_NKEY, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SEL_NODE, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_ACTR, METH_LOGICAL );
attrsAndMethods.put( KW_SET_ACTX, METH_CHAR );
attrsAndMethods.put( KW_SET_ATTR, METH_LOGICAL );
attrsAndMethods.put( KW_SET_A_N , METH_LOGICAL );
attrsAndMethods.put( KW_SET_BLUE, METH_LOGICAL );
attrsAndMethods.put( KW_SET_BRK , METH_LOGICAL );
attrsAndMethods.put( KW_SET_BUF , METH_LOGICAL );
attrsAndMethods.put( KW_SET_C_IC, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_C_S , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_C_VI, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_CB_P, METH_LOGICAL );
attrsAndMethods.put( KW_SET_CBAC, METH_LOGICAL );
attrsAndMethods.put( KW_SET_CLNT, METH_LOGICAL );
attrsAndMethods.put( KW_SET_COMM, METH_LOGICAL );
attrsAndMethods.put( KW_SET_C_P , METH_LOGICAL );
attrsAndMethods.put( KW_SET_CPTM, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_DYN , METH_LOGICAL );
attrsAndMethods.put( KW_SET_F_D , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_GRN , METH_LOGICAL );
attrsAndMethods.put( KW_SET_ISRC, METH_LOGICAL );
attrsAndMethods.put( KW_SET_LSTK, METH_LOGICAL ); // undocumented method (for LAST-EVENT handle) found in customer source, confirmed with test code
attrsAndMethods.put( KW_SET_IMGF, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_IMGH, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_IMGW, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_JMOD, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_JSTX, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_JSTY, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_M_UN, METH_LOGICAL );
attrsAndMethods.put( KW_SET_MSEL, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_N_BG, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_N_FG, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_N_HC, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_N_F , METH_LOGICAL );
attrsAndMethods.put( KW_SET_NODE, METH_LOGICAL );
attrsAndMethods.put( KW_SET_NTXT, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_ODST, METH_LOGICAL );
attrsAndMethods.put( KW_SET_PARM, METH_LOGICAL );
attrsAndMethods.put( KW_SET_PENW, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_PROP, METH_LOGICAL );
attrsAndMethods.put( KW_SET_RED , METH_LOGICAL );
attrsAndMethods.put( KW_SET_RGB , METH_LOGICAL );
attrsAndMethods.put( KW_SET_RRP , METH_LOGICAL );
attrsAndMethods.put( KW_SET_RPOS, METH_LOGICAL );
attrsAndMethods.put( KW_SET_ROLL, METH_LOGICAL );
attrsAndMethods.put( KW_SET_SEL , METH_LOGICAL );
attrsAndMethods.put( KW_SET_SERD, METH_LOGICAL );
attrsAndMethods.put( KW_SET_SWIN, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_R_P, METH_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_S_AR, METH_LOGICAL );
attrsAndMethods.put( KW_SET_S_O , METH_LOGICAL );
attrsAndMethods.put( KW_SET_SNC , METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_TBME, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_TN_I, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_TSTA, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SET_WAIT, METH_LOGICAL );
attrsAndMethods.put( KW_SHOW_BUT, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SHOW_ITB, ATTR_LOGICAL );
attrsAndMethods.put( KW_SHOW_HDR, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SHR_D_F , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SOR_C_C , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SOR_COLS, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SIDE_L , ATTR_LOGICAL );
attrsAndMethods.put( KW_SIDE_L_H, ATTR_HANDLE );
attrsAndMethods.put( KW_SING_RUN, ATTR_LOGICAL );
attrsAndMethods.put( KW_SINGLTON, ATTR_LOGICAL );
attrsAndMethods.put( KW_SKIP_D_R, ATTR_LOGICAL );
attrsAndMethods.put( KW_SMAL_ICO, ATTR_CHAR );
attrsAndMethods.put( KW_SMAL_TTL, ATTR_LOGICAL );
attrsAndMethods.put( KW_SMTPFROM, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPHOST, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPHTML, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTP_PW, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPPORT, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPREPL, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPSUBJ, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPTEXT, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTPUSER, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SMTP_VAL, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SOAP_F_A, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_F_C, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_F_D, ATTR_HANDLE );
attrsAndMethods.put( KW_SOAP_FMH, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_F_N, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_F_R, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_F_S, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_FSC, ATTR_CHAR );
attrsAndMethods.put( KW_SOAP_VER, ATTR_CHAR );
attrsAndMethods.put( KW_SOR_C_C, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SOR_COLS, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SORT , ATTR_LOGICAL );
attrsAndMethods.put( KW_SORT_ASC, ATTR_LOGICAL );
attrsAndMethods.put( KW_SORT_MAP, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_SORT_NUM, ATTR_INT );
attrsAndMethods.put( KW_SSL_SRVN, ATTR_CHAR );
attrsAndMethods.put( KW_STANDALN, ATTR_LOGICAL );
attrsAndMethods.put( KW_STATUS_A, ATTR_LOGICAL );
attrsAndMethods.put( KW_START_DC, METH_LOGICAL );
attrsAndMethods.put( KW_START_EL, METH_LOGICAL );
attrsAndMethods.put( KW_STAT_DET, ATTR_CHAR );
attrsAndMethods.put( KW_STAT_A_F, ATTR_INT );
attrsAndMethods.put( KW_STREAM , ATTR_CHAR );
attrsAndMethods.put( KW_START, METH_VOID ); // FWD TIMER extension
attrsAndMethods.put( KW_STOP , ATTR_LOGICAL );
attrsAndMethods.put( KW_STOP_PRS, METH_LOGICAL );
attrsAndMethods.put( KW_STOPPED , ATTR_LOGICAL );
attrsAndMethods.put( KW_STRICT , ATTR_LOGICAL );
attrsAndMethods.put( KW_STRIC_ER, ATTR_LOGICAL );
attrsAndMethods.put( KW_STR_VAL , ATTR_CHAR );
attrsAndMethods.put( KW_STUP_PAR, ATTR_CHAR );
attrsAndMethods.put( KW_ST_2_FIT, ATTR_LOGICAL );
attrsAndMethods.put( KW_SUBTYPE , ATTR_CHAR );
attrsAndMethods.put( KW_SUB_M_H , ATTR_LOGICAL ); // undocumented attribute seen in Possenet code, see adeshar/_mupdatm.p
attrsAndMethods.put( KW_SUP_NS_P, ATTR_LOGICAL );
attrsAndMethods.put( KW_SUP_PROC, ATTR_CHAR );
attrsAndMethods.put( KW_SUP_WARN, ATTR_LOGICAL );
attrsAndMethods.put( KW_SUPW_LST, ATTR_CHAR );
attrsAndMethods.put( KW_SYM_EN_A, ATTR_CHAR );
attrsAndMethods.put( KW_SYM_EN_I, ATTR_RAW );
attrsAndMethods.put( KW_SYM_EN_K, ATTR_RAW );
attrsAndMethods.put( KW_SYM_SUPP, ATTR_CHAR );
attrsAndMethods.put( KW_SYNCHRON, METH_LOGICAL );
attrsAndMethods.put( KW_SYS_A_B , ATTR_LOGICAL );
attrsAndMethods.put( KW_SYS_ID , ATTR_CHAR );
attrsAndMethods.put( KW_3D , ATTR_LOGICAL );
attrsAndMethods.put( KW_TABS , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TAB_IDX , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TAB_ML , ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TAB_MOD, METH_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TAB_POS , ATTR_INT );
attrsAndMethods.put( KW_TAB_SHOW, METH_VOID ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TAB_STOP, ATTR_LOGICAL );
attrsAndMethods.put( KW_TABLE , ATTR_CHAR );
attrsAndMethods.put( KW_TAB_CRCL, ATTR_CHAR );
attrsAndMethods.put( KW_TAB_HAND, ATTR_HANDLE );
attrsAndMethods.put( KW_TAB_LIST, ATTR_CHAR );
attrsAndMethods.put( KW_TAB_NUM , ATTR_INT );
attrsAndMethods.put( KW_TEMP_DIR, ATTR_CHAR );
attrsAndMethods.put( KW_TEN_ID , METH_INT );
attrsAndMethods.put( KW_TENNAME , METH_CHAR );
attrsAndMethods.put( KW_TERM_HK , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TEXTEDIT, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_THO_SEP , ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_THR_SAFE, ATTR_LOGICAL );
attrsAndMethods.put( KW_TRC_FILT, ATTR_CHAR ); // undocumented, found in customer code
attrsAndMethods.put( KW_TRAC_CHG, ATTR_LOGICAL );
attrsAndMethods.put( KW_TREE_R_H, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TXT_SEL , ATTR_LOGICAL );
attrsAndMethods.put( KW_TIC_MARK, ATTR_CHAR );
attrsAndMethods.put( KW_TITLE , ATTR_CHAR );
attrsAndMethods.put( KW_TIMEZONE, ATTR_INT );
attrsAndMethods.put( KW_TIME_SRC, ATTR_CHAR );
attrsAndMethods.put( KW_TITL_BGC, ATTR_INT );
attrsAndMethods.put( KW_TITL_DC , ATTR_INT );
attrsAndMethods.put( KW_TITL_FGC, ATTR_INT );
attrsAndMethods.put( KW_TITL_FON, ATTR_INT );
attrsAndMethods.put( KW_TT_PREP , METH_LOGICAL );
attrsAndMethods.put( KW_TNOD_VAL, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TOGGL_BX, ATTR_LOGICAL );
attrsAndMethods.put( KW_TOOLTIP , ATTR_CHAR );
attrsAndMethods.put( KW_TOOLTIPS, ATTR_LOGICAL );
attrsAndMethods.put( KW_TOP_NAVQ, ATTR_HANDLE );
attrsAndMethods.put( KW_TOP_ONLY, ATTR_LOGICAL );
attrsAndMethods.put( KW_TRACING, ATTR_CHAR ); // undocumented, found in customer code
attrsAndMethods.put( KW_TRANS , ATTR_HANDLE );
attrsAndMethods.put( KW_TRAN_I_P, ATTR_HANDLE );
attrsAndMethods.put( KW_TRANSPAR, ATTR_LOGICAL );
attrsAndMethods.put( KW_TRIG_NOD, ATTR_HANDLE ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TRIG_COL, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_TYPE , ATTR_CHAR );
attrsAndMethods.put( KW_UNDO , ATTR_LOGICAL );
attrsAndMethods.put( KW_UNDO_T_S, ATTR_CHAR );
attrsAndMethods.put( KW_UNIQ_ID , ATTR_INT );
attrsAndMethods.put( KW_UNIQ_KEY, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_UNIQ_MAT, ATTR_LOGICAL );
attrsAndMethods.put( KW_UPD_ATTR, METH_LOGICAL );
attrsAndMethods.put( KW_URL , ATTR_CHAR );
attrsAndMethods.put( KW_URL_DECO, METH_CHAR );
attrsAndMethods.put( KW_URL_ENCO, METH_CHAR );
attrsAndMethods.put( KW_URL_PW , ATTR_CHAR );
attrsAndMethods.put( KW_URL_UID , ATTR_CHAR );
attrsAndMethods.put( KW_USR_DATA, METH_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_USER_ID , ATTR_CHAR );
attrsAndMethods.put( KW_UTC_OFF , ATTR_INT );
attrsAndMethods.put( KW_V_N_CNT , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_V_R_CNT , ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_V_SCRL_P, ATTR_INT ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_V6DISP , ATTR_LOGICAL );
attrsAndMethods.put( KW_VALUE , ATTR_CHAR );
attrsAndMethods.put( KW_VAL_ENAB, ATTR_LOGICAL );
attrsAndMethods.put( KW_VAL_EXPR, ATTR_CHAR );
attrsAndMethods.put( KW_VAL_MSG , ATTR_CHAR );
attrsAndMethods.put( KW_VAL_SEAL, METH_LOGICAL );
attrsAndMethods.put( KW_VAL_XML , ATTR_LOGICAL );
attrsAndMethods.put( KW_VALIDATE, METH_LOGICAL );
attrsAndMethods.put( KW_VERSION , ATTR_CHAR );
attrsAndMethods.put( KW_VIEW_AS , ATTR_CHAR );
attrsAndMethods.put( KW_VIEW_FCR, ATTR_LOGICAL );
attrsAndMethods.put( KW_VIRT_HC , ATTR_DEC );
attrsAndMethods.put( KW_VIRT_HP , ATTR_INT );
attrsAndMethods.put( KW_VIRT_WC , ATTR_DEC );
attrsAndMethods.put( KW_VIRT_WP , ATTR_INT );
attrsAndMethods.put( KW_VISIBLE , ATTR_LOGICAL );
attrsAndMethods.put( KW_WHERE_ST, ATTR_CHAR );
attrsAndMethods.put( KW_WID_ENT , ATTR_HANDLE );
attrsAndMethods.put( KW_WID_ID , ATTR_INT );
attrsAndMethods.put( KW_WID_LEAV, ATTR_HANDLE );
attrsAndMethods.put( KW_WIDTH_C , ATTR_DEC );
attrsAndMethods.put( KW_WIDTH_P , ATTR_INT );
attrsAndMethods.put( KW_WIN_STAT, ATTR_INT );
attrsAndMethods.put( KW_WIN_SYS , ATTR_CHAR );
attrsAndMethods.put( KW_WINDOW , ATTR_HANDLE );
attrsAndMethods.put( KW_WA_H_P , ATTR_INT );
attrsAndMethods.put( KW_WA_W_P , ATTR_INT );
attrsAndMethods.put( KW_WA_X , ATTR_INT );
attrsAndMethods.put( KW_WA_Y , ATTR_INT );
attrsAndMethods.put( KW_WARN , ATTR_LOGICAL );
attrsAndMethods.put( KW_WC_AD_AP, ATTR_LOGICAL );
attrsAndMethods.put( KW_WORD_WRP, ATTR_LOGICAL );
attrsAndMethods.put( KW_WRITE , METH_LOGICAL );
attrsAndMethods.put( KW_WR_CDATA, METH_LOGICAL );
attrsAndMethods.put( KW_WR_CHARS, METH_LOGICAL );
attrsAndMethods.put( KW_WR_CMNT , METH_LOGICAL );
attrsAndMethods.put( KW_WR_DATA , METH_LOGICAL ); // undocumented, found in customer code
attrsAndMethods.put( KW_WR_D_ELM, METH_LOGICAL );
attrsAndMethods.put( KW_WR_E_ELM, METH_LOGICAL );
attrsAndMethods.put( KW_WR_ENT_R, METH_LOGICAL );
attrsAndMethods.put( KW_WR_EXDTD, METH_LOGICAL );
attrsAndMethods.put( KW_WR_FRAGM, METH_LOGICAL );
attrsAndMethods.put( KW_WR_JSON , METH_LOGICAL );
attrsAndMethods.put( KW_WR_MSG , METH_LOGICAL );
attrsAndMethods.put( KW_WR_PRINS, METH_LOGICAL );
attrsAndMethods.put( KW_WR_STAT , ATTR_INT );
attrsAndMethods.put( KW_WR_XML , METH_LOGICAL );
attrsAndMethods.put( KW_WR_XMLSC, METH_LOGICAL );
attrsAndMethods.put( KW_WUPL_ERR, ATTR_LOGICAL ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_WUPL_FLS, ATTR_CHAR ); // FWD extension, not real 4GL
attrsAndMethods.put( KW_X , ATTR_INT );
attrsAndMethods.put( KW_XML_DTYP, ATTR_CHAR );
attrsAndMethods.put( KW_XML_E_EL, ATTR_INT );
attrsAndMethods.put( KW_XML_NNAM, ATTR_CHAR );
attrsAndMethods.put( KW_XML_NTYP, ATTR_CHAR );
attrsAndMethods.put( KW_XML_SCHP, ATTR_CHAR );
attrsAndMethods.put( KW_XML_S_ER, ATTR_LOGICAL );
attrsAndMethods.put( KW_XML_SNSP, ATTR_LOGICAL );
attrsAndMethods.put( KW_X_DOC , ATTR_HANDLE );
attrsAndMethods.put( KW_Y , ATTR_INT );
attrsAndMethods.put( KW_YEAR_OFF, ATTR_INT );
return attrsAndMethods;
}
/**
* Loads the <code>SymbolResolver</code> with Progress 4GL built-in
* variables and any built-in functions which DO NOT take parameters. This
* is called during construction to ensure that the functions are
* available before parsing begins.
* <p>
* Built-in functions that have no parameters are treated as variables.
* This is done because this is an exact syntactic and semantic match
* for such constructions. The fact that the Progress language names
* such items functions has no meaning. For this reason, this function is
* used to handle such built-ins.
* <p>
* Each variable is added with the full name (even if the keyword supports
* abbreviations) because the {@link #lvalue} method will detect when
* a keyword is being used and it will use the keyword dictionary to
* handle the abbreviation support. This lookup will convert any
* abbreviated text to the full text before lookup in the variable
* dictionary.
* <p>
* All variables are added with the token type associated with their
* respective return value.
* <p>
* For built-in functions that take parameters, see
* {@link #initializeFunctionDictionary}.
* <p>
* This method also enables the matching of all valid system handles:
* <p>
* <pre>
* ACTIVE_WINDOW
* CLIPBOARD
* CODEBASE-LOCATOR
* COLOR-TABLE
* COM-SELF
* COMPILER
* CURRENT-WINDOW
* DEBUGGER
* DEFAULT-WINDOW
* ERROR-STATUS
* FILE-INFO
* FOCUS
* FONT-TABLE
* LAST-EVENT
* RCODE-INFO
* SELF
* SESSION
* SOURCE-PROCEDURE
* TARGET-PROCEDURE
* THIS-PROCEDURE
* WEB-CONTEXT
* </pre>
* <p>
* Note that there are some built-in functions that can act like variables
* OR as a normal parenthesized function. In other words, for the
* following list, the parenthesis are optional:
* <p>
* <ul>
* <li>AUDIT-ENABLED
* <li>ETIME
* <li>FRAME-COL
* <li>FRAME-DOWN
* <li>FRAME-LINE
* <li>FRAME-ROW
* <li>GUID
* <li>LINE-COUNTER
* <li>PAGE-NUMBER
* <li>PAGE-SIZE
* <li>SUPER (handled in super_function rule instead of here)
* <li>TRANS or TRANSACTION
* <li>USERID (and it's synonym USER which is not an abbreviation)
* </ul>
* <p>
* Such variables/functions are included in both this rule and in
* <code>initializeFunctionDictionary</code>. The token type for such
* constructs is set to the function version <code>FUNC_</code> instead of
* the variable version <code>VAR_</code>.
*/
private void initializeVariableDictionary()
{
if (sym.isRuntimeConfig())
{
// already initialized from an exemplar
return;
}
for (String kw : getSysHandles())
{
sym.addGlobalVariable(kw, SYS_HANDLE);
}
sym.addGlobalVariable("_control" , VAR_CHAR );
sym.addGlobalVariable("_msg" , FUNC_INT );
sym.addGlobalVariable("_pcontrol" , VAR_CHAR );
sym.addGlobalVariable("_serial-num" , VAR_INT );
sym.addGlobalVariable("active-form" , VAR_CLASS , "Progress.Windows.IForm" );
sym.addGlobalVariable("audit-enabled" , FUNC_LOGICAL );
sym.addGlobalVariable("current-language" , VAR_CHAR );
sym.addGlobalVariable("dataservers" , VAR_CHAR );
sym.addGlobalVariable("dbname" , VAR_CHAR );
sym.addGlobalVariable("etime" , FUNC_INT64 );
sym.addGlobalVariable("exclusive-lock" , VAR_INT ); // used as a symbolic constant in handle-based method calls as a valid integer expression
sym.addGlobalVariable("frame-col" , FUNC_DEC );
sym.addGlobalVariable("frame-db" , VAR_CHAR );
sym.addGlobalVariable("frame-down" , FUNC_INT );
sym.addGlobalVariable("frame-field" , VAR_CHAR );
sym.addGlobalVariable("frame-file" , VAR_CHAR );
sym.addGlobalVariable("frame-index" , VAR_INT );
sym.addGlobalVariable("frame-line" , FUNC_INT );
sym.addGlobalVariable("frame-name" , VAR_CHAR );
sym.addGlobalVariable("frame-row" , FUNC_DEC );
sym.addGlobalVariable("frame-value" , VAR_CHAR );
sym.addGlobalVariable("fwd-client-driver" , VAR_CHAR ); // FWD extension, not real 4GL!
sym.addGlobalVariable("gateways" , VAR_CHAR );
sym.addGlobalVariable("generate-pbe-salt" , VAR_RAW );
sym.addGlobalVariable("generate-random-key", VAR_RAW );
sym.addGlobalVariable("generate-uuid" , VAR_RAW );
sym.addGlobalVariable("get-codepages" , VAR_CHAR );
sym.addGlobalVariable("go-pending" , VAR_LOGICAL );
sym.addGlobalVariable("guid" , FUNC_CHAR ); // built-in function with optional parens, this is the undocumented form
sym.addGlobalVariable("is-attr-space" , VAR_LOGICAL );
sym.addGlobalVariable("lastkey" , VAR_INT );
sym.addGlobalVariable("last-key" , VAR_INT );
sym.addGlobalVariable("line-counter" , FUNC_INT );
sym.addGlobalVariable("message-lines" , VAR_INT );
sym.addGlobalVariable("mtime" , FUNC_INT ); // entry here with a FUNC_ type suggests this can have optional parens, is that correct?
sym.addGlobalVariable("no-lock" , VAR_INT ); // used as a symbolic constant in handle-based method calls as a valid integer expression
sym.addGlobalVariable("no-wait" , VAR_INT ); // used as a symbolic constant in handle-based method calls as a valid integer expression
sym.addGlobalVariable("now" , FUNC_DATETIME_TZ ); // entry here with a FUNC_ type suggests this can have optional parens, is that correct?
sym.addGlobalVariable("num-aliases" , VAR_INT );
sym.addGlobalVariable("num-dbs" , VAR_INT );
sym.addGlobalVariable("opsys" , VAR_CHAR );
sym.addGlobalVariable("os-drives" , VAR_CHAR );
sym.addGlobalVariable("os-error" , VAR_INT );
sym.addGlobalVariable("os-userid" , VAR_CHAR ); // FWD extension, not real 4GL!
sym.addGlobalVariable("page-number" , FUNC_INT );
sym.addGlobalVariable("page-size" , FUNC_INT );
sym.addGlobalVariable("process-architecture", VAR_INT );
sym.addGlobalVariable("proc-handle" , VAR_INT );
sym.addGlobalVariable("proc-status" , VAR_INT );
sym.addGlobalVariable("progress" , VAR_CHAR );
sym.addGlobalVariable("promsgs" , VAR_CHAR );
sym.addGlobalVariable("propath" , VAR_CHAR );
sym.addGlobalVariable("proversion" , FUNC_CHAR ); // can have optional parens (and a single parameter)
sym.addGlobalVariable("retry" , FUNC_LOGICAL ); // entry here with a FUNC_ type suggests this can have optional parens, is that correct?
sym.addGlobalVariable("return-value" , VAR_CHAR );
sym.addGlobalVariable("rt-opsys" , VAR_CHAR ); // FWD extension, not real 4GL!
sym.addGlobalVariable("screen-lines" , VAR_INT );
sym.addGlobalVariable("share-lock" , VAR_INT ); // used as a symbolic constant in handle-based method calls as a valid integer expression
sym.addGlobalVariable("term" , VAR_CHAR ); // TODO: is this needed?
sym.addGlobalVariable("terminal" , VAR_CHAR );
sym.addGlobalVariable("time" , FUNC_INT ); // entry here with a FUNC_ type suggests this can have optional parens, is that correct?
sym.addGlobalVariable("timezone" , FUNC_INT ); // entry here with a FUNC_ type suggests this can have optional parens, is that correct?
sym.addGlobalVariable("today" , FUNC_DATE ); // entry here with a FUNC_ type suggests this can have optional parens, is that correct?
sym.addGlobalVariable("trans" , FUNC_LOGICAL );
sym.addGlobalVariable("transaction" , FUNC_LOGICAL );
sym.addGlobalVariable("user" , FUNC_CHAR );
sym.addGlobalVariable("userid" , FUNC_CHAR );
}
/**
* Loads the <code>SymbolResolver</code> with Progress 4GL internal
* procedures that are well known. This is called during construction
* to ensure that the functions are available before parsing begins.
* <p>
* These procedures are normally implemented by 4GL code in WebSpeed
* but their definitions are being placed here so that code can parse
* without any PSC 4GL code. Most of these are old WebSpeed 1.0 interfaces
* that are deprecated but still supported for backwards compatibility.
*/
private void initializeProcedureDictionary()
{
if (webspeed)
{
sym.addProcedure("adm-timing-out" , WEB_PROC );
sym.addProcedure("AsciiToHtml" , WEB_PROC ); // html-encode()
sym.addProcedure("CookieDate" , WEB_PROC ); // format-cookie()
sym.addProcedure("DeleteCookie" , WEB_PROC ); // delete-cookie()
sym.addProcedure("dispatch" , WEB_PROC );
sym.addProcedure("get-transaction-state", WEB_PROC );
sym.addProcedure("getAttribute" , WEB_PROC );
sym.addProcedure("GetCGI" , WEB_PROC ); // get-cgi()
sym.addProcedure("GetCookie" , WEB_PROC ); // get-cookie()
sym.addProcedure("GetField" , WEB_PROC ); // get-field()
sym.addProcedure("HtmlError" , WEB_PROC );
sym.addProcedure("init-session" , WEB_PROC );
sym.addProcedure("OutputContentType" , WEB_PROC ); // output-content-type()
sym.addProcedure("outputHeader" , WEB_PROC );
sym.addProcedure("outputHeaders" , WEB_PROC ); // same as outputHeader
sym.addProcedure("OutputHttpHeader" , WEB_PROC ); // output-http-header()
sym.addProcedure("process-web-request" , WEB_PROC );
sym.addProcedure("run-web-object" , WEB_PROC );
sym.addProcedure("set-attribute-list" , WEB_PROC );
sym.addProcedure("set-transaction-state", WEB_PROC );
sym.addProcedure("SetCookie" , WEB_PROC ); // set-cookie()
sym.addProcedure("UrlDecode" , WEB_PROC ); // url-decode()
sym.addProcedure("UrlEncode" , WEB_PROC ); // url-encode()
sym.addProcedure("web.output" , WEB_PROC );
}
}
/**
* Loads the <code>SymbolResolver</code> with Progress 4GL internal
* streams that are well known. This is called during construction
* to ensure that the streams are available before parsing begins.
* <p>
* These streams are normally implemented by 4GL code in WebSpeed
* but their definitions are being placed here so that code can parse
* without any PSC 4GL code.
*/
private void initializeStreamDictionary()
{
if (webspeed)
{
sym.addStream("WebStream", STREAM);
}
}
/**
* Common routine to rewrite the data, field type based on a requirement
* for additional abbreviation support (beyond that which can normally be
* used in the rest of the Progress language.
* <p>
* The 2nd lookahead token is read for its text. If it is one of the
* valid (expected) keywords, then this method returns immediately.
* Otherwise, a check is made for any of the special abbreviations
* that follow:
* <pre>
* Data Type Keyword Actual Minimum Abbrev Lexer Abbrev
* ----------------- --------------------- -------------
* KW_BLOB n/a n/a
* KW_CHAR c char
* KW_CLASS n/a n/a
* KW_CLOB n/a n/a
* KW_COM_HNDL n/a n/a
* KW_DATE da n/a
* KW_DATETIME n/a n/a
* KW_DATE_TZ n/a n/a
* KW_DEC de dec
* KW_HANDLE handle n/a
* KW_INT i int
* KW_INT64 n/a n/a
* KW_LOGICAL l n/a
* KW_LONGCHAR n/a n/a
* KW_MEMPTR m mem
* KW_RAW ra n/a
* KW_RECID re n/a
* KW_ROWID row n/a
* KW_WID_HAND widg widget-h
* The following are supported in native interfaces:
* KW_BYTE n/a n/a
* KW_DOUBLE n/a n/a
* KW_FLOAT n/a n/a
* KW_LONG n/a n/a
* KW_SHORT n/a n/a
* KW_UNS_SHRT n/a n/a
* </pre>
* <p>
* If one of these (from the actual column above) is matched, the token
* type of the 2nd lookahead token is rewritten with the associated
* data/field type keyword. Otherwise an exception is thrown.
* <p>
* This method exists simply to centralize the processing that is used
* in both {@link #as_clause} and {@link #as_field_clause}. NOTE that
* callers MUST ensure that any necessary pull methods (such as
* {@link #reserved_or_symbol}) are included to properly generate the
* predication logic that will allow the full set of possibilities to
* actually be encountered.
*
* @param lookahead
* Number of tokens to look ahead.
*/
private void specialDataTypeKeywordAbbreviations(int lookahead)
throws TokenStreamException
{
int sec = LA(lookahead);
// override token type for 2nd token IF it already is NOT a match
// to one of our required data type keywords
if (sec != KW_BLOB &&
sec != KW_CHAR &&
sec != KW_CLASS &&
sec != KW_CLOB &&
sec != KW_COM_HNDL &&
sec != KW_DATE &&
sec != KW_DATETIME &&
sec != KW_DATE_TZ &&
sec != KW_DEC &&
sec != KW_INT &&
sec != KW_INT64 &&
sec != KW_LOGICAL &&
sec != KW_LONGCHAR &&
sec != KW_RECID &&
sec != KW_ROWID &&
sec != KW_HANDLE &&
sec != KW_WID_HAND &&
sec != KW_RAW &&
sec != KW_MEMPTR &&
sec != KW_BYTE &&
sec != KW_DOUBLE &&
sec != KW_FLOAT &&
sec != KW_LONG &&
sec != KW_SHORT &&
sec != KW_UNS_SHRT &&
sec != KW_POLY)
{
String text = LT(lookahead).getText().toLowerCase();
int newtype = -1;
if (text.equals("c") || text.equals("ch") || text.equals("cha"))
{
newtype = KW_CHAR;
}
else if (text.equals("da") || text.equals("dat"))
{
newtype = KW_DATE;
}
else if (text.equals("de"))
{
newtype = KW_DEC;
}
else if (text.equals("i") || text.equals("in"))
{
newtype = KW_INT;
}
else if (text.equals("l") || text.equals("lo") ||
text.equals("log") || text.equals("logi") ||
text.equals("logic") || text.equals("logica"))
{
newtype = KW_LOGICAL;
}
else if (text.equals("m") || text.equals("me"))
{
newtype = KW_MEMPTR;
}
else if (text.equals("ra"))
{
newtype = KW_RAW;
}
else if (text.equals("re") || text.equals("rec") ||
text.equals("reci"))
{
newtype = KW_RECID;
}
else if (text.equals("row") || text.equals("rowi"))
{
newtype = KW_ROWID;
}
else if (text.equals("widg") || text.equals("widge") ||
text.equals("widget") || text.equals("widget-"))
{
newtype = KW_WID_HAND;
}
// at this point, there should always be a match in valid
// Progress 4GL source so we throw an exception if this is
// not the case
if (newtype != -1)
{
LT(lookahead).setType(newtype);
}
}
}
/**
* Check if this token is a user-defined function call. The method checks whether the first
* token is marked as type <code>KW_CLOSE</code> or <code>KW_COMPILE</code> with next token
* being a <code>LPARENS</code>: in this case, transform it to <code>SYMBOL</code>, as it
* will be a function or OO method call.
*
* @param tok1
* First token, typically LT(1).
* @param tok2
* Second token, typically LT(2).
*
* @return <code>true</code> if the type of this token was changed.
*/
private boolean isUserDefFunctionCall(Token tok1, Token tok2)
{
if (tok2.getType() != LPARENS)
{
return false;
}
// CLOSE or COMPILE is not a reserved keyword, thus can be used in a function name;
// we need to disambiguate between a close or compile function call and close or
// compile statement.
// this needs to be disambiguated done here, otherwise it wouldn't be converted
// properly
if (tok1.getType() == KW_CLOSE ||
tok1.getType() == KW_COMPILE)
{
tok1.setType(SYMBOL);
return true;
}
return false;
}
/**
* Simple helper to return the given node if it is a field type or if it
* is an expression node, its first child will be returned if that child
* is a field type.
*
* @param possible
* The given node to test, cannot be <code>null</code>.
*
* @return The field node found or <code>null</code> if no field node
* was found.
*/
private Aast findFieldNode(Aast possible)
{
int ttype = possible.getType();
// dereference first child if this is an expression node
if (ttype == EXPRESSION)
{
possible = (Aast) possible.getFirstChild();
ttype = possible.getType();
}
// is the node a field type
if (ttype > BEGIN_FIELDTYPES && ttype < END_FIELDTYPES)
{
return possible;
}
return null;
}
/**
* Check if the USE-DICT-EXPS frame option is set for this frame. If is not active, then also
* remove all validation and help options pulled from the schema by this statement.
*
* @param frame
* The frame name.
* @param framePhrase
* The FRAME_PHRASE AST.
* @param stmt
* The current UI statement.
*/
private void setUseDictExps(String frame, Aast framePhrase, Aast stmt)
{
// clear the "schema-processed" annotation for all fields
Set<Aast> fields = sym.getFrameFields(frame);
if (fields != null)
{
for (Aast fld : fields)
{
fld.removeAnnotation("schema-processed");
}
}
boolean prevUseDictExps = sym.isUseDictExps(frame);
if (framePhrase != null && framePhrase.downPath(KW_USE_DCT))
{
sym.markUseDictExps(frame);
}
// if USE-DICT-EXPS is not set for this frame and this statement is not one which pulls the
// schema validation automatically, then remove all KW_VALIDATE[schema_validation=true] and
// KW_HELP[schema_help=true] nodes from this statement.
int type = stmt.getType();
if (!sym.isUseDictExps(frame) &&
!(type == KW_ENABLE ||
type == KW_SET ||
type == KW_UPDATE ||
type == KW_PRMT_FOR ||
type == KW_INSERT))
{
// fixup the parents so nodes can be removed
((ProgressAst) stmt).fixupParent(null);
List<Aast> remove = new ArrayList<>();
Iterator<Aast> iter = stmt.iterator();
while (iter.hasNext())
{
Aast ref = iter.next();
int rtype = ref.getType();
if (rtype == KW_VALIDATE &&
ref.isAnnotation("schema_validation") &&
(Boolean) ref.getAnnotation("schema_validation"))
{
remove.add(ref);
}
// schema-level help is allowed to remain only if we are an UI statement which
// enables the field. otherwise, both the KW_HELP node and the field-level "help"
// annotation will be removed.
if (rtype == KW_HELP &&
ref.isAnnotation("schema_help") &&
(Boolean) ref.getAnnotation("schema_help"))
{
remove.add(ref);
}
if (rtype > BEGIN_FIELDTYPES && rtype < END_FIELDTYPES)
{
ref.removeAnnotation("help");
}
}
Set<Aast> formatPhrases = new HashSet<>();
for (Aast ref : remove)
{
formatPhrases.add(ref.getParent());
ref.remove();
}
for (Aast ref : formatPhrases)
{
if (ref.getNumImmediateChildren() == 0)
{
ref.remove();
}
}
}
// if USE-DICT-EXPS is set before this statement, then remove the VALEXP and HELP nodes for
// all field widgets
if (prevUseDictExps)
{
// fixup the parents so nodes can be removed
((ProgressAst) stmt).fixupParent(null);
List<Aast> remove = new ArrayList<>();
Iterator<Aast> iter = stmt.iterator();
while (iter.hasNext())
{
Aast ref = iter.next();
int rtype = ref.getType();
if (rtype == KW_HELP || rtype == KW_VALIDATE)
{
// check if the format_phrase is associated with a widget...
Aast formatPhrase = ref.getParent();
Aast widgetRef = formatPhrase.getPrevSibling();
if (widgetRef.getType() == EXPRESSION)
{
widgetRef = (Aast) widgetRef.getFirstChild();
}
int wtype = widgetRef.getType();
if (wtype > BEGIN_FIELDTYPES && wtype < END_FIELDTYPES)
{
// this is a HELP or VALEXP associated with a field, so remove it...
remove.add(ref);
}
}
if (rtype > BEGIN_FIELDTYPES && rtype < END_FIELDTYPES)
{
ref.removeAnnotation("help");
}
}
Set<Aast> formatPhrases = new HashSet<>();
for (Aast ref : remove)
{
formatPhrases.add(ref.getParent());
ref.remove();
}
for (Aast ref : formatPhrases)
{
if (ref.getNumImmediateChildren() == 0)
{
ref.remove();
}
}
}
}
/**
* Simple helper to extract a frame name from a frame phrase node. If a null frame phrase node
* is provided, or the given node has no KW_FRAME child, an empty string is returned.
*
* @param framePhrase
* Frame phrase node, or <code>null</code>.
*
* @return The frame name extracted from FRAME_PHRASE/KW_FRAME/WID_FRAME, or empty string if
* a name could not be found (this is the equivalent to the default frame).
*/
private String getFrameName(Aast framePhrase)
{
if (framePhrase == null)
{
return "";
}
Aast kwFrame = framePhrase.getImmediateChild(KW_FRAME, null);
if (kwFrame == null)
{
return "";
}
return kwFrame.getFirstChild().getText();
}
/**
* Disambiguates a record reference from an {@link #lvalue} or an
* {@link #expr} by checking that there is no exact match with a
* variable name and that the name would match a table name in the
* schema dictionary. The variable dictionary lookup must be handled
* here since variable names hide table names AND since we match record
* references in a different rule ({@link #record}) than where we match
* variables and fields (<code>lvalue</code>). In particular, this
* rule must force a match on records before fields, but since the
* matching of variables and fields is hidden in <code>lvalue</code>
* we must disambiguate here.
*
* @param text
* The name (possibly abbreviated) of the potential record
* reference.
*
* @return <code>true</code> if this is a record reference.
*/
private boolean isRecord(String text)
{
return ((sym.lookupVariable(text) == -1) && sym.isTable(text));
}
/**
* Use lookahead to determine if the qualified database name quirk is
* present in the given tokens. In such a case, the source code has
* whitespace between the record name and the DOT and/or whitespace
* between the DOT and the fieldname portions but Progress treats this as
* a properly qualified field name.
*
* @param tok1
* First token, typically LT(1).
* @param tok2
* Second token, typically LT(2).
* @param tok3
* Third token, typically LT(3).
*
* @return <code>true</code> if the name quirk is detected.
*/
private boolean isQualifiedFieldNameQuirk(Token tok1,
Token tok2,
Token tok3)
{
int t3 = tok3.getType();
if (t3 >= BEGIN_RESERVED && t3 <= END_RESERVED)
{
// can't use reserved names as field names (abbreviations or not).
return false;
}
boolean result = false;
String text = tok1.getText();
if (isRecord(text) && tok2.getType() == DOT)
{
if (followedByWhitespace(tok1) || followedByWhitespace(tok2))
{
StringBuilder sb = new StringBuilder();
sb.append(text).append('.').append(tok3.getText());
result = (sym.lookupField(currentRecord, sb.toString()) != -1);
}
}
return result;
}
/**
* Returns <code>true</code> if the given type is <code>KW_CHAR</code>,
* <code>KW_LONGCHAR</code>, <code>VAR_CHAR</code>,
* <code>VAR_LONGCHAR</code>, <code>FIELD_CHAR</code> or
* <code>FIELD_CLOB</code>.
*
* @param type
* Token type to test.
*
* @return <code>true</code> if the type represents character data.
*/
private boolean isCharType(int type)
{
return (type == KW_CHAR ||
type == KW_LONGCHAR ||
type == VAR_CHAR ||
type == VAR_LONGCHAR ||
type == FIELD_CHAR ||
type == FIELD_CLOB);
}
/**
* Returns <code>true</code> if the given type is <code>KW_DATE</code>,
* <code>KW_DATETIME</code>, <code>KW_DATE_TZ</code>, <code>VAR_DATE</code>,
* <code>VAR_DATETIME</code>, <code>VAR_DATETIME_TZ</code>, <code>FIELD_DATE</code>,
* <code>FIELD_DATETIME</code> or <code>FIELD_DATETIME_TZ</code>.
*
* @param type
* Token type to test.
*
* @return <code>true</code> if the type represents date data.
*/
private boolean isDateType(int type)
{
return (type == KW_DATE ||
type == KW_DATETIME ||
type == KW_DATE_TZ ||
type == VAR_DATE ||
type == VAR_DATETIME ||
type == VAR_DATETIME_TZ ||
type == FIELD_DATE ||
type == FIELD_DATETIME ||
type == FIELD_DATETIME_TZ);
}
/**
* Returns <code>true</code> if the given type is <code>KW_DATETIME</code>, <code>VAR_DATETIME</code> or
* <code>FIELD_DATETIME</code>.
*
* @param type
* Token type to test.
*
* @return <code>true</code> if the type represents datetime data.
*/
private boolean isDateTimeType(int type)
{
return (type == KW_DATETIME || type == VAR_DATETIME || type == FIELD_DATETIME);
}
/**
* Returns <code>true</code> if the given type is <code>KW_DATE_TZ</code>, <code>VAR_DATETIME_TZ</code> or
* <code>FIELD_DATETIME_TZ</code>.
*
* @param type
* Token type to test.
*
* @return <code>true</code> if the type represents datetime-tz data.
*/
private boolean isDateTimeTzType(int type)
{
return (type == KW_DATE_TZ || type == VAR_DATETIME_TZ || type == FIELD_DATETIME_TZ);
}
/**
* Returns <code>true</code> if the given type is <code>KW_INT</code>,
* <code>KW_INT64</code>, <code>KW_RECID</code>, <code>VAR_INT</code>,
* <code>VAR_INT64</code>, <code>VAR_RECID</code>, <code>FIELD_INT</code>,
* <code>FIELD_INT64</code> or <code>FIELD_RECID</code>.
*
* @param type
* Token type to test.
*
* @return <code>true</code> if the type represents date data.
*/
private boolean isNumericType(int type)
{
return (type == KW_INT ||
type == KW_INT64 ||
type == KW_RECID ||
type == KW_DEC ||
type == VAR_INT ||
type == VAR_INT64 ||
type == VAR_RECID ||
type == VAR_DEC ||
type == FIELD_INT ||
type == FIELD_INT64 ||
type == FIELD_RECID ||
type == FIELD_DEC);
}
/**
* Returns <code>true</code> if the given type is a variable, field,
* function, method, attribute that refers to a handle or if it is a
* system handle.
*
* @param node
* AST node to test.
*
* @return <code>true</code> if the type represents handle data.
*/
private boolean isHandleType(Aast node)
{
int type = node.getType();
return (type == VAR_HANDLE ||
type == FIELD_HANDLE ||
type == FUNC_HANDLE ||
type == ATTR_HANDLE ||
type == METH_HANDLE ||
type == OO_METH_HANDLE ||
type == SYS_HANDLE);
}
/**
* Returns <code>true</code> if the given type is a variable, field, function, method,
* attribute or system handle that refers to a COM-HANDLE.
*
* @param lvalue
* AST node to test.
*
* @return <code>true</code> if the type represents COM-HANDLE data.
*/
private boolean isComHandleType(Aast lvalue)
{
int type = lvalue.getType();
String text = null;
if (type == FIELD_HANDLE)
{
text = (String) lvalue.getAnnotation("schemaname");
}
if (type == VAR_HANDLE)
{
text = lvalue.getText();
}
if (type == SYS_HANDLE)
{
Long otype = (Long) lvalue.getAnnotation("oldtype");
if (otype != null && otype.longValue() == KW_COM_SELF)
return true;
}
return (type == VAR_COM_HANDLE ||
type == FIELD_COM_HANDLE ||
type == FUNC_COM_HANDLE ||
type == ATTR_COM_HANDLE ||
type == METH_COM_HANDLE ||
type == OO_METH_COM_HANDLE);
}
/**
* Returns <code>true</code> if the given subtree resolves to a <code>VAR_CLASS</code>,
* <code>FIELD_CLASS</code>, <code>FUNC_CLASS</code>, <code>METH_CLASS</code>,
* <code>CLASS_NAME</code> or if this is a built-in attribute or non-user defined method call
* <code>COLON</code> that has a <code>ATTR_CLASS</code> or <code>METH_CLASS</code> in the
* index position 1.
* <p>
* Parenthesis will be ignored and the contained sub-expression will be checked.
*
* @param node
* AST node to test.
*
* @return <code>true</code> if the type represents an object reference.
*/
private boolean isObjectSubtree(Aast node)
{
int type = node.getType();
Aast ref = node;
while (ref != null && type == LPARENS)
{
ref = ref.getChildAt(0);
if (ref == null)
{
break;
}
type = ref.getType();
}
return isObjectType(type);
}
/**
* Returns <code>true</code> if the given type is <code>VAR_CLASS</code>,
* <code>FIELD_CLASS</code>, <code>FUNC_CLASS</code>, <code>METH_CLASS</code>,
* <code>CLASS_NAME</code>, <code>ATTR_CLASS</code> or a bitwise operator.
*
* @param type
* The type to test.
*
* @return <code>true</code> if the type represents an object reference.
*/
private boolean isObjectType(int type)
{
return (type == CLASS_NAME ||
type == VAR_CLASS ||
type == FIELD_CLASS ||
type == FUNC_CLASS ||
type == ATTR_CLASS ||
type == METH_CLASS ||
type == OO_METH_CLASS ||
type == BITWISE_OR ||
type == BITWISE_AND ||
type == BITWISE_XOR ||
type == BITWISE_NOT);
}
/**
* Report if this token type is one of the primitive types.
*
* @param type
* The token type to check.
*
* @return {@code true} if this is a primitive type.
*/
private boolean isPrimitiveType(int type)
{
switch (type)
{
case KW_CHAR:
case KW_COM_HNDL:
case KW_DATE:
case KW_DATETIME:
case KW_DATE_TZ:
case KW_DEC:
case KW_HANDLE:
case KW_WID_HAND:
case KW_INT:
case KW_INT64:
case KW_LOGICAL:
case KW_LONGCHAR:
case KW_RECID:
case KW_ROWID:
case KW_RAW:
case KW_MEMPTR:
case KW_BYTE:
case KW_DOUBLE:
case KW_FLOAT:
case KW_LONG:
case KW_SHORT:
case KW_UNS_LONG:
case KW_UNS_SHRT:
case KW_POLY:
return true;
}
return false;
}
/**
* Returns <code>true</code> if the given type is an object reference (including a class name)
* whose fully qualified classname is an enum.
*
* @param node
* The node to test.
*
* @return <code>true</code> if the type represents an enum reference.
*/
private boolean isEnum(Aast node)
{
int type = node.getType();
Aast ref = node;
while (ref != null && type == LPARENS)
{
ref = ref.getChildAt(0);
if (ref == null)
{
break;
}
type = ref.getType();
}
// bitwise operators as operands means the result is an enum
if (type == BITWISE_OR || type == BITWISE_AND || type == BITWISE_XOR || type == BITWISE_NOT)
{
return true;
}
// the most common case is enum-type-name:enum-member; the 2nd child is the result type for the
// expression
if (type == OBJECT_INVOCATION)
{
ref = ref.getChildAt(1);
type = ref.getType();
}
if (isObjectType(type))
{
String cname = getObjectClassName(ref);
if (cname == null)
{
// should not happen, but safety first
return false;
}
if ("Progress.Lang.Enum".equalsIgnoreCase(cname) ||
"Progress.Lang.FlagsEnum".equalsIgnoreCase(cname) ||
"System.Enum".equalsIgnoreCase(cname))
{
// the class def won't report as an enum, but these are the parent classes for all
// enums, so they also count as enums
return true;
}
ClassDefinition cls = sym.lookupClass(cname);
if (cls != null && cls.isEnum())
{
return true;
}
}
return false;
}
/**
* Returns <code>true</code> if the given subtree resolves to a <code>CLASS_NAME</code>.
* Parenthesis will be ignored and the contained sub-expression will be checked.
*
* @param node
* AST node to test.
*
* @return <code>true</code> if the type represents an class reference.
*/
private boolean isStaticObject(Aast node)
{
int type = node.getType();
Aast ref = node;
while (ref != null && type == LPARENS)
{
ref = ref.getChildAt(0);
if (ref == null)
{
break;
}
type = ref.getType();
}
return (type == CLASS_NAME);
}
/**
* Bypass any LPARENS and return the referenced node.
*
* @param node
* AST node which is the object reference.
*
* @return The referenced node.
*/
private Aast findRefnode(Aast node)
{
int type = node.getType();
Aast ref = node;
while (ref != null && type == LPARENS)
{
ref = ref.getChildAt(0);
if (ref == null)
{
break;
}
type = ref.getType();
}
return ref;
}
/**
* Annotate the given member if it should be a generic type parameter.
*
* @param node
* AST node which is the object reference.
* @param member
* The member to be checked.
*/
private void testAndSaveGenericType(Aast node, Aast member)
{
// special case for .NET classes that implement generics
if (member != null && member.getText().toLowerCase().equals("item"))
{
Aast ref = findRefnode(node);
if (ref.isAnnotation("generic-type-parameter"))
{
String type = (String) ref.getAnnotation("generic-type-parameter");
member.putAnnotation("generic-type-parameter", type);
}
if (ref.isAnnotation("generic-type-is-primitive"))
{
boolean prim = (boolean) ref.getAnnotation("generic-type-is-primitive");
member.putAnnotation("generic-type-is-primitive", prim);
}
}
}
/**
* Find the class name referenced by the given object reference.
*
* @param node
* AST node which is the object reference.
*
* @return The fully qualified class name of the object this node references or <code>null</code> if
* the reference is not to an object.
*/
private String getObjectClassName(Aast node)
{
Aast ref = findRefnode(node);
String cls = (String) ref.getAnnotation("qualified");
// the Item property of an object instance that has a generic type parameter will be returned as
// that generic type; this was saved off earlier in the chaining process; this is only for .NET
if (("item".equals(ref.getText().toLowerCase()) || node.downPath(LBRACKET)) &&
ref.isAnnotation("generic-type-parameter"))
{
return (String) ref.getAnnotation("generic-type-parameter");
}
if (ref.downPath(LBRACKET))
{
// a subscript on a non-extent var might be a .NET collection which can be dereferenced
if (!ref.isAnnotation("extent") || (long) ref.getAnnotation("extent") == 0)
{
// this is an implicit reference to the "Item" property
String itemCls = sym.lookupDataMemberClass(cls, "Item", false);
if (itemCls != null)
{
cls = itemCls;
}
}
}
else
{
if (ref.isAnnotation("dotnet-array"))
{
// we have a .NET-style array without a '[' bracket, treat this as an array
cls = "System.Array";
}
}
return cls;
}
/**
* Handle annotation of variables.
*
* @param name
* Variable name.
* @param type
* Variable type.
* @param node
* AST node to be annotated.
*/
private void annotateVariable(String name, int type, Aast node)
{
// write any non-standard options into annotations
sym.annotateVariableOptions(currentClassName,
currentStaticFlag,
name,
node,
false);
if (type == VAR_CLASS && !node.isAnnotation("qualified"))
{
// this must be a class-based data member (var or property)
// so we need to lookup the class name and force the
// annotation
String qname = sym.lookupDataMemberClass(currentClassName,
name,
currentStaticFlag);
// make our best effort to recover from an unknown class ref
if (qname == null)
{
ClassDefinition cls = sym.getCurrentClassDef();
int otype = -1;
if (node.isAnnotation("oldtype"))
{
Long ot = (Long) node.getAnnotation("oldtype");
otype = ot.intValue();
}
// this should only be possible for two special cases
if (otype == KW_THIS_OBJ)
{
qname = cls.getName();
}
else if (otype == KW_SUPER)
{
// super cannot be used unless there is a parent class, but we are going to be
// safe here so we have a null check; note that by definition interfaces and
// enums cannot have any 4GL code that is an implementation and SUPER can only
// appear in an implementation (e.g. a method body); thus we know that only
// a class (not an interface or enum) can be used here which means a single
// possible parent
ClassDefinition[] parents = cls.getParents();
qname = parents != null && parents[0] != null ? parents[0].getName() : null;
}
}
// should always be non-null, but we are being safe here
if (qname != null)
sym.annotateClassRef(qname, node);
}
}
/**
* Add the data member to a class definition if needed (this should only be called for
* variables, properties and events.
*
* @param varname
* Resource name being defined.
* @param ttype
* The stmt type being processed.
* @param def
* The definition node for this member.
* @param typeDef
* AS node (vars or props), LIKE node (vars) or SIGNATURE (events).
* @param am
* Access mode node if specified.
* @param st
* Static node if specified.
* @param ov
* Override node if specified.
* @param ab
* Abstract node if specified.
* @param extent
* The extent value or 0 if there is no extent.
*/
private void processMember(String varname,
int ttype,
Aast def,
Aast typeDef,
Aast am,
Aast st,
Aast ov,
Aast ab,
int extent)
{
// only define a new data member if we are not inside an OO code block
if (!inMethodDef)
{
// force this as a data member of any active class definition (all 3 types share the
// same namespace); this must be done before the annotations are written into the
// definition because the Variable instance state is modified for properties and this
// may result in different annotations
if (ttype == DEFINE_VARIABLE || ttype == DEFINE_PROPERTY || ttype == DEFINE_EVENT)
{
String qname = null;
// calc the fully qualified name for class vars and props
if (ttype == DEFINE_VARIABLE || ttype == DEFINE_PROPERTY)
{
// typeDef must not be null here, it will be either an AS clause (vars or props)
// or it will be a LIKE clause (vars only); it will always have a child node
// which defines the type
Aast child = typeDef.getChildAt(0);
int ctype = child.getType();
// some types reference classes and we must know the qualified name in those
// cases
if (ctype == CLASS_NAME || // AS object instance reference
ctype == VAR_CLASS || // LIKE object instance var
ctype == FIELD_CLASS) // LIKE object instance field
{
qname = (String) child.getAnnotation("qualified");
}
}
sym.addDataMember(ttype, varname, def, am, st, ov, ab, qname, extent);
if (ttype == DEFINE_EVENT)
{
// annotate the parameters for this class event
SymbolResolver.processDefinitionSignature(typeDef, (Aast ast, ParameterKey pk, int idx) ->
{
ast.putAnnotation("jtype", pk.toJava());
});
}
}
}
}
/**
* Post processing for variables and other data members (e.g. properties, events).
*
* @param varname
* Resource name being defined.
* @param root
* The define stmt root node.
* @param am
* Access mode node if specified.
* @param st
* Static node if specified.
* @param force
* Mark parameter type as input when c<code>true</code>.
*/
private void postDefineVar(String varname, Aast root, Aast am, Aast st, boolean force)
{
int ttype = root.getType();
// force this as a data member of any active class definition (all 3 types share the same
// namespace); this must be done before the annotations are written into the definition
// because the Variable instance state is modified for properties and this may result
// in different annotations
if (ttype == DEFINE_VARIABLE || ttype == DEFINE_PROPERTY || ttype == DEFINE_EVENT)
{
String qname = null;
// calc the fully qualified name for class vars and props
if (ttype == DEFINE_VARIABLE || ttype == DEFINE_PROPERTY)
{
Aast as = root.getImmediateChild(KW_AS, null);
// look for an AS clause
if (as != null)
{
// if this is an object instance reference, get the class
// name of the type
Aast cname = as.getChildAt(0);
if (cname.getType() == CLASS_NAME)
{
qname = (String) cname.getAnnotation("qualified");
}
}
else
{
// must be a LIKE clause
Aast like = root.getImmediateChild(KW_LIKE, null);
Aast lval = like.getChildAt(0);
int ltype = lval.getType();
if (ltype == VAR_CLASS || ltype == FIELD_CLASS)
{
qname = (String) lval.getAnnotation("qualified");
}
}
}
if (qname != null)
{
sym.annotateClassRef(qname, root);
}
}
// pass the AST with all options to the symbol resolver to set
// those variable options accordingly
sym.setVariableOptions(varname, root);
// write any non-standard options into annotations
sym.annotateVariableOptions(varname, root, true);
// check if this is a define_parameter and if the parameter type
// was specified
if (force)
{
// no type specified, default to KW_INPUT
root.putAnnotation("parmtype", Long.valueOf(KW_INPUT));
}
}
/**
* Post processing for buffers.
*
* @param tablename
* Buffer name being defined.
* @param root
* The define stmt root node.
*/
private void postDefineBuf(String tablename, Aast root)
{
// now store an annotation with the fully qualified name and the
// shorted unabbreviated unique buffer name
String fullname = sym.lookupFullTableName(tablename);
String bufname = sym.lookupBufferName(tablename, false);
String dbname = sym.lookupDatabaseName(tablename);
if (fullname != null)
{
root.putAnnotation("schemaname", fullname);
}
if (bufname != null)
{
root.putAnnotation("bufname", bufname);
}
if (dbname != null)
{
root.putAnnotation("dbname", dbname);
}
}
/**
* Patch the given token into the hidden token stream as if it was lexed that way.
*
* @param t
* The token to be hidden.
*/
private void hide(Token t)
{
ManagedHiddenStreamToken tok = (ManagedHiddenStreamToken) t;
tok.hide();
}
/**
* Walk the given subtree and for each node, patch the original token into the hidden token
* stream as if it was lexed that way.
*
* @param ast
* The subtree to walk.
*/
private void hide(Aast ast)
{
Iterator<Aast> iter = ast.iterator();
while (iter.hasNext())
{
Aast node = iter.next();
// if the subtree has artificial nodes, there won't be an original token to retrieve
if (node.isAnnotation("original-token"))
{
ManagedHiddenStreamToken tok =
(ManagedHiddenStreamToken) node.getAnnotation("original-token");
tok.hide();
}
// TODO: remove this temporary debugging code
else
{
System.out.printf("Missing original-token annotation for %s\n", node.dumpTree());
}
}
}
/**
* Provides a command line interface for an end user to drive and/or test
* this class.
* <p>
* Syntax:
* <pre>
* java ProgressParser [-v] <Progress_4GL_source_file>
* </pre>
* Where:
* <ul>
* <li> [-v] if present will enable visual mode, causing the tree to be
* displayed inside a Swing GUI panel
* <li> <Progress_4GL_source_file> is the filename of a
* preprocessed Progress 4GL source file (enclose the name in
* double quotes if spaces or other reserved command line
* characters are part of the filename)
* </ul>
*
* @param args
* List of command line arguments.
*/
public static void main(String[] args)
{
String syntax = "Syntax: java ProgressParser [-v] <4gl_source_file>";
// filename is required
if (args.length < 1)
{
LOG.log(Level.SEVERE, syntax);
System.exit(-1);
}
boolean visual = false;
String fname = args[0];
// honor visual mode
if (args.length == 2 && "-v".equals(args[0]))
{
visual = true;
fname = args[1];
}
try
{
// setup
SymbolResolver sym = new SymbolResolver(true);
FileReader fr = new FileReader(fname);
BufferedReader br = new BufferedReader(fr);
ProgressLexer lexer = new ProgressLexer(br, sym);
ProgressParser parser = new ProgressParser(lexer, sym);
// parse the input file and create a tree
parser.external_proc();
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("Progress 4GL Source File", result);
frame.setVisible(true);
}
}
catch(Exception excpt)
{
LOG.log(Level.SEVERE, "", excpt);
}
}
protected ProgressParser(TokenBuffer tokenBuf, int k) {
super(tokenBuf,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public ProgressParser(TokenBuffer tokenBuf) {
this(tokenBuf,3);
}
protected ProgressParser(TokenStream lexer, int k) {
super(lexer,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public ProgressParser(TokenStream lexer) {
this(lexer,3);
}
public ProgressParser(ParserSharedInputState state) {
super(state,3);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
/**
* Pre-scan (1st pass) at reading a class definition to pre-load the symbol
* resolver with the class' internal resources. Class resources can be
* referenced before their definitions appear which is why this pre-scan
* is needed. This does not fully parse the code. Instead it takes a
* highly abbreviated scan which ignores most content. This should only
* be called on a class definition. The AST that results should be ignored.
* <p>
* At this time, the only things processed here are the following (everything
* else is ignored):
* <p>
* <ul>
* <li> {@link #using_stmt}
* <li> {@link #class_stmt}
* <li> {@link #interface_stmt}
* <li> {@link #define_stmt_pre_scan}
* <li> {@link #method_stmt}
* </ul>
* <p>
* The above are reparsed on the 2nd pass but some of the configuration is only
* processed on the 1st pass. The <code>method_stmt</code> is an exception
* since the method AST nodes need to be annotated.
*/
public final void pre_scan_class() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast pre_scan_class_AST = null;
Aast cstmt_AST = null;
try { // for error handling
preScanPass++;
topLevelEntry = true;
boolean all = false;
boolean explicitCtor = false;
boolean enumStmt = false;
{
_loop3:
do {
if ((LA(1)==KW_USING) && (_tokenSet_0.member(LA(2))) && (LA(3)==DOT||LA(3)==KW_FROM)) {
using_stmt();
}
else if ((((LA(1) >= DOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( LA(1) != KW_CLASS && LA(1) != KW_INTERFAC && LA(1) != KW_ENUM )) {
matchNot(EOF);
}
else {
break _loop3;
}
} while (true);
}
sym.addScope();
{
switch ( LA(1)) {
case KW_CLASS:
{
class_stmt();
cstmt_AST = (Aast)returnAST;
break;
}
case KW_INTERFAC:
{
interface_stmt();
break;
}
case KW_ENUM:
{
enum_stmt();
enumStmt = true;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop7:
do {
if (((LA(1)==KW_DEFINE) && (LA(2)==KW_ENUM) && (_tokenSet_1.member(LA(3))))&&( enumStmt )) {
def_enum_stmt();
}
else if ((LA(1)==KW_DEFINE) && (_tokenSet_2.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
define_stmt_pre_scan();
}
else if ((LA(1)==KW_METHOD) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
sym.addScope();
method_stmt();
sym.deleteScope();
}
else if ((LA(1)==KW_RUN) && (LA(2)==KW_CONSTRUC) && (_tokenSet_3.member(LA(3)))) {
{
Aast tmp2_AST = null;
tmp2_AST = (Aast)astFactory.create(LT(1));
match(KW_RUN);
Aast tmp3_AST = null;
tmp3_AST = (Aast)astFactory.create(LT(1));
match(KW_CONSTRUC);
}
}
else if ((LA(1)==KW_CONSTRUC) && (_tokenSet_1.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
sym.addScope();
constructor_stmt();
sym.deleteScope(); explicitCtor = true;
}
else if ((((LA(1) >= DOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != EOF )) {
matchNot(EOF);
}
else {
break _loop7;
}
} while (true);
}
if (!explicitCtor && cstmt_AST != null)
{
String clsName = sym.getCurrentClassName();
int dotIdx = clsName.lastIndexOf('.');
if (dotIdx >= 0)
{
clsName = clsName.substring(dotIdx + 1);
}
Aast ctorNode = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(KW_CONSTRUC,"constructor")).add((Aast)astFactory.create(KW_PUBLIC,"public")).add((Aast)astFactory.create(LPARENS,"(")));
cstmt_AST.graft(ctorNode);
sym.addObjectMethod(clsName, OO_METH_VOID, KW_PUBLIC, false, ctorNode, null);
}
sym.deleteScope();
preScanPass--;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = pre_scan_class_AST;
}
/**
* Matches the <code>USING</code> language statement which has a
* <code>KW_USING</code> node followed by an {@link #any_symbol_at_all}.
* After the symbol, because of the way the lexer works, it is possible to
* match a <code>DOT</code> and then a <code>MULTIPLY</code>. This text is
* merged into the symbol if found. Finally, an optional {@link #from_assembly}
* clause can be matched.
* <p>
* This updates the symbol resolver's package list with the symbol text. That
* is subsequently used to resolve unqualified class names into fully
* qualified package + class names.
* <p>
* Called by {@link #stmt_list}.
*/
public final void using_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast using_stmt_AST = null;
Token u = null;
Aast u_AST = null;
Aast sy_AST = null;
Token dt = null;
Aast dt_AST = null;
Token m = null;
Aast m_AST = null;
Token st = null;
Aast st_AST = null;
Aast f_AST = null;
try { // for error handling
u = LT(1);
u_AST = (Aast)astFactory.create(u);
astFactory.makeASTRoot(currentAST, u_AST);
match(KW_USING);
{
if ((_tokenSet_1.member(LA(1)))) {
any_symbol_at_all();
sy_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==DOT) && (LA(2)==MULTIPLY) && (LA(3)==DOT||LA(3)==KW_FROM)) {
dt = LT(1);
dt_AST = (Aast)astFactory.create(dt);
match(DOT);
hide(dt);
m = LT(1);
m_AST = (Aast)astFactory.create(m);
match(MULTIPLY);
hide(m);
}
else if ((LA(1)==DOT||LA(1)==KW_FROM) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((LA(1)==STRING)) {
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(STRING);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_FROM:
{
from_assembly();
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
using_stmt_AST = (Aast)currentAST.root;
StringBuilder sb = new StringBuilder();
if (st_AST != null)
{
// we aren't saving this back into the node's text so we don't have to do anything
// special
String txt = character.progressToJavaString(st_AST.getText(), !unixEscapes, false);
sb.append(StringHelper.processEscapes(txt));
}
else
{
sb.append(sy_AST.getText());
if (m_AST != null)
{
sb.append(".*");
saveAndReplaceText(sy_AST, sb.toString());
}
}
sym.addPackage(getFilename(), u_AST, sb.toString(), f_AST);
if (preScanPass == 0)
{
String searchSpec = sb.toString();
using_stmt_AST.putAnnotation("search_spec", searchSpec);
if (!searchSpec.endsWith("*"))
{
String simpleName = searchSpec.substring(searchSpec.lastIndexOf('.') + 1);
using_stmt_AST.putAnnotation("simple_name", simpleName.toLowerCase());
}
}
using_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = using_stmt_AST;
}
/**
* Implements the structure of a <code>CLASS</code> language statement.
* <p>
* The most important feature of this rule is the direct usage of the {@link #any_symbol_at_all} rule to
* force the second token to a <code>SYMBOL</code> token type. This token is then used in the exit action
* to add the class definition. .NET inner classes are supported by matching a {@code PLUS}
* followed by another {@code any_symbol_at_all}.
*/
public final void class_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast class_stmt_AST = null;
Aast s_AST = null;
Token pl = null;
Aast pl_AST = null;
Aast innerCls_AST = null;
Token st = null;
Aast st_AST = null;
Aast inher_AST = null;
Aast impl_AST = null;
try { // for error handling
{
Aast tmp5_AST = null;
tmp5_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp5_AST);
match(KW_CLASS);
{
if ((_tokenSet_1.member(LA(1)))) {
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case PLUS:
{
pl = LT(1);
pl_AST = (Aast)astFactory.create(pl);
match(PLUS);
hide(pl);
any_symbol_at_all();
innerCls_AST = (Aast)returnAST;
hide(innerCls_AST);
saveAndReplaceText(s_AST, s_AST.getText() + "+" + innerCls_AST.getText());
break;
}
case DOT:
case KW_ABSTRACT:
case KW_FINAL:
case KW_IMPLEMTS:
case KW_INHERITS:
case KW_SERIALAB:
case KW_USE_WIDP:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==STRING)) {
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(STRING);
String txt = character.progressToJavaString(st_AST.getText(), !unixEscapes, false);
saveAndReplaceTypeAndText(st_AST, SYMBOL, txt);
s_AST = st_AST;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop66:
do {
switch ( LA(1)) {
case KW_INHERITS:
{
inherits_clause();
inher_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IMPLEMTS:
{
implements_clause();
impl_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ABSTRACT:
case KW_FINAL:
{
{
switch ( LA(1)) {
case KW_ABSTRACT:
{
Aast tmp6_AST = null;
tmp6_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp6_AST);
match(KW_ABSTRACT);
break;
}
case KW_FINAL:
{
Aast tmp7_AST = null;
tmp7_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp7_AST);
match(KW_FINAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_SERIALAB:
{
Aast tmp8_AST = null;
tmp8_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp8_AST);
match(KW_SERIALAB);
break;
}
case KW_USE_WIDP:
{
Aast tmp9_AST = null;
tmp9_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp9_AST);
match(KW_USE_WIDP);
break;
}
default:
{
break _loop66;
}
}
} while (true);
}
block_term();
astFactory.addASTChild(currentAST, returnAST);
}
sym.addClass(s_AST, inher_AST, impl_AST, getFilename());
builtInCls = sym.isBuiltInClass(s_AST.getText());
dotNetCls = sym.isDotNetClass(s_AST.getText());
class_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = class_stmt_AST;
}
/**
* Implements the structure of a <code>INTERFACE</code> language statement.
* <p>
* The most important feature of this rule is the direct usage of the {@link #any_symbol_at_all} rule to
* force the second token to a <code>SYMBOL</code> token type. This token is then used in the exit action
* to add the interface's definition. .NET inner interfaces are supported by matching a {@code PLUS}
* followed by another {@code any_symbol_at_all}.
*/
public final void interface_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast interface_stmt_AST = null;
Aast s_AST = null;
Token pl = null;
Aast pl_AST = null;
Aast innerCls_AST = null;
Token st = null;
Aast st_AST = null;
Aast inher_AST = null;
try { // for error handling
{
Aast tmp10_AST = null;
tmp10_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp10_AST);
match(KW_INTERFAC);
{
if ((_tokenSet_1.member(LA(1)))) {
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case PLUS:
{
pl = LT(1);
pl_AST = (Aast)astFactory.create(pl);
match(PLUS);
hide(pl);
any_symbol_at_all();
innerCls_AST = (Aast)returnAST;
hide(innerCls_AST);
saveAndReplaceText(s_AST, s_AST.getText() + "+" + innerCls_AST.getText());
break;
}
case DOT:
case KW_INHERITS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==STRING)) {
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(STRING);
String txt = character.progressToJavaString(st_AST.getText(), !unixEscapes, false);
saveAndReplaceTypeAndText(st_AST, SYMBOL, txt);
s_AST = st_AST;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_INHERITS:
{
multiple_inherits_clause();
inher_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
block_term();
astFactory.addASTChild(currentAST, returnAST);
}
sym.addInterface(s_AST, inher_AST, getFilename());
builtInCls = sym.isBuiltInClass(s_AST.getText());
dotNetCls = sym.isDotNetClass(s_AST.getText());
interface_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = interface_stmt_AST;
}
/**
* Implements the structure of an <code>ENUM</code> language statement.
* <p>
* The most important feature of this rule is the direct usage of the
* {@link #any_symbol_at_all} rule to force the second token to a
* <code>SYMBOL</code> token type. This token is then used in the exit
* action to add the interface's definition.
*/
public final void enum_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast enum_stmt_AST = null;
Aast s_AST = null;
Token pl = null;
Aast pl_AST = null;
Aast innerCls_AST = null;
Token st = null;
Aast st_AST = null;
Token f = null;
Aast f_AST = null;
try { // for error handling
{
Aast tmp11_AST = null;
tmp11_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp11_AST);
match(KW_ENUM);
{
if ((_tokenSet_1.member(LA(1)))) {
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case PLUS:
{
pl = LT(1);
pl_AST = (Aast)astFactory.create(pl);
match(PLUS);
hide(pl);
any_symbol_at_all();
innerCls_AST = (Aast)returnAST;
hide(innerCls_AST);
saveAndReplaceText(s_AST, s_AST.getText() + "+" + innerCls_AST.getText());
break;
}
case DOT:
case KW_FLAGS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==STRING)) {
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(STRING);
String txt = character.progressToJavaString(st_AST.getText(), !unixEscapes, false);
saveAndReplaceTypeAndText(st_AST, SYMBOL, txt);
s_AST = st_AST;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_FLAGS:
{
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.addASTChild(currentAST, f_AST);
match(KW_FLAGS);
break;
}
case DOT:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
block_term();
astFactory.addASTChild(currentAST, returnAST);
}
sym.addEnum(s_AST, (f_AST != null), getFilename());
builtInCls = sym.isBuiltInClass(s_AST.getText());
dotNetCls = sym.isDotNetClass(s_AST.getText());
enum_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = enum_stmt_AST;
}
/**
* Matches {@code KW_DEFINE KW_ENUM} followed by one or more {@link #enum_member} references and
* a {@link #stmt_term}. The root node will be {@code DEFINE_ENUM}.
*/
public final void def_enum_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_enum_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token e = null;
Aast e_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DEFINE);
d_AST.setType(DEFINE_ENUM);
e = LT(1);
e_AST = (Aast)astFactory.create(e);
match(KW_ENUM);
hide(e);
{
int _cnt95=0;
_loop95:
do {
if ((_tokenSet_1.member(LA(1)))) {
enum_member();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt95>=1 ) { break _loop95; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt95++;
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
def_enum_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_enum_stmt_AST;
}
/**
* Matches the <code>DEFINE</code> Progress 4GL language statement and
* switches into the correct alternative based on the lookahead tokens.
* <p>
* This rule is called by {@link #stmt_list} and it handles the matching
* for the <code>DEFINE</code> keyword, the optional shared scope keywords
* <code>NEW, GLOBAL, SHARED</code> and the optional keywords for parameter
* types <code>INPUT, OUTPUT, INPUT-OUTPUT and RETURN</code>. It then
* calls the appropriate alternative to allow the specific processing to
* occur. The alternatives:
* <ul>
* <li> BROWSE {@link #def_browse_stmt}
* <li> BUTTON {@link #def_button_stmt}
* <li> BUFFER {@link #def_buf_stmt}
* <li> DATASET {@link #def_dataset_stmt}
* <li> DATA-SOURCE {@link #def_datasrc_stmt}
* <li> EVENT {@link #def_event_stmt}
* <li> FRAME {@link #def_frame_stmt}
* <li> IMAGE {@link #def_image_stmt}
* <li> MENU and SUB-MENU {@link #def_menu_stmt}
* <li> PARAMETER {@link #def_parm_stmt}
* <li> PROPERTY {@link #def_prop_stmt}
* <li> RECTANGLE {@link #def_rect_stmt}
* <li> STREAM {@link #def_stream_stmt}
* <li> QUERY {@link #def_query_stmt}
* <li> TEMP-TABLE (and WORK-TABLE/WORKFILE) {@link #def_temp_table_stmt}
* <li> VARIABLE {@link #def_var_stmt}
* </ul>
* <p>
* This design allows all <code>DEFINE</code> statements to be supported
* without ambiguity because it left-factors the common keyword.
*/
public final void define_stmt_pre_scan() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast define_stmt_pre_scan_AST = null;
Token d = null;
Aast d_AST = null;
Aast am_AST = null;
Token st = null;
Aast st_AST = null;
Token ab = null;
Aast ab_AST = null;
Token ov = null;
Aast ov_AST = null;
Aast t_AST = null;
Token k1 = null;
Aast k1_AST = null;
Token k2 = null;
Aast k2_AST = null;
Token k3 = null;
Aast k3_AST = null;
Token k4 = null;
Aast k4_AST = null;
try { // for error handling
int mtype = -1;
String varname = null;
String dsName = null;
String tablename = null;
boolean force = false;
boolean fakeBuffer = false;
Aast likeast = null;
String likename = null;
boolean tt_new = false;
boolean tt_global = false;
boolean tt_shared = false;
boolean always = false;
boolean[] allowColon = new boolean[] { false };
Object[] df = null;
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DEFINE);
{
_loop174:
do {
switch ( LA(1)) {
case KW_PK_PRIV:
case KW_PK_PROT:
case KW_PRIVATE:
case KW_PROTECTD:
case KW_PUBLIC:
{
access_mode();
am_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SERIALAB:
{
Aast tmp12_AST = null;
tmp12_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp12_AST);
match(KW_SERIALAB);
break;
}
case KW_NON_SER:
{
Aast tmp13_AST = null;
tmp13_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp13_AST);
match(KW_NON_SER);
break;
}
case KW_STATIC:
{
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(KW_STATIC);
break;
}
case KW_ABSTRACT:
{
ab = LT(1);
ab_AST = (Aast)astFactory.create(ab);
astFactory.addASTChild(currentAST, ab_AST);
match(KW_ABSTRACT);
break;
}
case KW_OVERRIDE:
{
ov = LT(1);
ov_AST = (Aast)astFactory.create(ov);
astFactory.addASTChild(currentAST, ov_AST);
match(KW_OVERRIDE);
break;
}
case KW_FINAL:
{
Aast tmp14_AST = null;
tmp14_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp14_AST);
match(KW_FINAL);
break;
}
default:
{
break _loop174;
}
}
} while (true);
}
{
switch ( LA(1)) {
case KW_DATA_SRC:
case KW_DATASET:
case KW_FRAME:
case KW_NEW:
case KW_QUERY:
case KW_SHARED:
case KW_STREAM:
case KW_WORK_TAB:
case KW_BROWSE:
case KW_BUFFER:
case KW_MENU:
case KW_SUB_MENU:
case KW_TEMP_TAB:
case KW_VAR:
{
{
if (((LA(1)==KW_NEW||LA(1)==KW_SHARED))&&( am_AST == null )) {
{
switch ( LA(1)) {
case KW_NEW:
{
Aast tmp15_AST = null;
tmp15_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp15_AST);
match(KW_NEW);
{
switch ( LA(1)) {
case KW_GLOBAL:
{
Aast tmp16_AST = null;
tmp16_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp16_AST);
match(KW_GLOBAL);
tt_global = true;
break;
}
case KW_SHARED:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
tt_new = true;
break;
}
case KW_SHARED:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp17_AST = null;
tmp17_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp17_AST);
match(KW_SHARED);
tt_shared = true;
}
else if ((_tokenSet_7.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_BROWSE:
{
varname=def_browse_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BROWSE);
break;
}
case KW_BUFFER:
{
def_buf_stmt(true, false, (tt_shared && ! tt_new), am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BUFFER);
break;
}
case KW_DATASET:
{
dsName=def_dataset_stmt(am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_DATASET);
// add the dataset to the namespace
sym.addDataSet(dsName, DATA_SET, d_AST, am_AST, st_AST);
break;
}
case KW_DATA_SRC:
{
dsName=def_datasrc_stmt(am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_DATA_SOURCE);
// add the data source to the namespace
sym.addDataSource(dsName, DATA_SOURCE, d_AST, am_AST, st_AST);
break;
}
case KW_FRAME:
{
df=def_frame_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_FRAME);
String frame = (String) df[0];
Aast fp = (Aast) df[1];
setUseDictExps(frame, fp, d_AST);
break;
}
case KW_MENU:
case KW_SUB_MENU:
{
mtype=def_menu_stmt();
astFactory.addASTChild(currentAST, returnAST);
define_stmt_pre_scan_AST = (Aast)currentAST.root;
if (mtype == WID_MENU)
{
d_AST.setType(DEFINE_MENU);
}
else
{
d_AST.setType(DEFINE_SUB_MENU);
}
varname = define_stmt_pre_scan_AST.getImmediateChild(SYMBOL, null).getText();
likeast = define_stmt_pre_scan_AST.getImmediateChild(KW_LIKE, null);
if (likeast != null)
{
likename = likeast.getImmediateChild(SYMBOL, null).getText();
sym.addMenuLike(varname, likename, define_stmt_pre_scan_AST);
}
break;
}
case KW_QUERY:
{
def_query_stmt(am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_QUERY);
break;
}
case KW_STREAM:
{
def_stream_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_STREAM);
break;
}
case KW_WORK_TAB:
case KW_TEMP_TAB:
{
tablename=def_temp_table_stmt(tt_new, tt_global, tt_shared, am_AST, st_AST);
t_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
fakeBuffer = true;
if (t_AST.getType() == KW_TEMP_TAB)
{
d_AST.setType(DEFINE_TEMP_TABLE);
}
else
{
d_AST.setType(DEFINE_WORK_TABLE);
}
break;
}
case KW_VAR:
{
varname=def_var_stmt(allowColon, d_AST, am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_VARIABLE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_INPUT:
case KW_IN_OUT:
case KW_OUTPUT:
case KW_PARM:
case KW_RETURN:
{
{
switch ( LA(1)) {
case KW_INPUT:
{
k1 = LT(1);
k1_AST = (Aast)astFactory.create(k1);
astFactory.addASTChild(currentAST, k1_AST);
match(KW_INPUT);
break;
}
case KW_OUTPUT:
{
k2 = LT(1);
k2_AST = (Aast)astFactory.create(k2);
astFactory.addASTChild(currentAST, k2_AST);
match(KW_OUTPUT);
break;
}
case KW_IN_OUT:
{
k3 = LT(1);
k3_AST = (Aast)astFactory.create(k3);
astFactory.addASTChild(currentAST, k3_AST);
match(KW_IN_OUT);
break;
}
case KW_RETURN:
{
k4 = LT(1);
k4_AST = (Aast)astFactory.create(k4);
astFactory.addASTChild(currentAST, k4_AST);
match(KW_RETURN);
break;
}
case KW_PARM:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
varname=def_parm_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_PARAMETER);
if (k1_AST == null && k2_AST == null && k3_AST == null && k4_AST == null)
{
force = true;
}
break;
}
case KW_PROPERTY:
{
varname=def_prop_stmt_pre_scan(d_AST, am_AST, st_AST, ov_AST, ab_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_PROPERTY); always = true;
break;
}
case KW_EVENTS:
{
varname=def_event_stmt(d_AST, am_AST, st_AST, ov_AST, ab_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_EVENT); always = true;
break;
}
case KW_BUTTON:
{
varname=def_button_stmt(allowColon);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BUTTON);
break;
}
case KW_RECT:
{
varname=def_rect_stmt(allowColon);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_RECTANGLE);
break;
}
case KW_IMAGE:
{
varname=def_image_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_IMAGE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
define_stmt_pre_scan_AST = (Aast)currentAST.root;
// defining data members is bypassed for default members
if (am_AST != null || always)
{
if (varname != null)
{
postDefineVar(varname, define_stmt_pre_scan_AST, am_AST, st_AST, force);
}
if (dsName != null)
{
sym.setDatasetOptions(null, false, dsName, define_stmt_pre_scan_AST, d_AST.getType(), true);
}
}
if (fakeBuffer)
{
postDefineBuf(tablename, define_stmt_pre_scan_AST);
}
define_stmt_pre_scan_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = define_stmt_pre_scan_AST;
}
public final void method_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast method_stmt_AST = null;
Aast a_AST = null;
Token st = null;
Aast st_AST = null;
Aast cls_AST = null;
Aast s_AST = null;
int mtype = -1;
int size = -1;
try { // for error handling
Aast tmp18_AST = null;
tmp18_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp18_AST);
match(KW_METHOD);
{
_loop126:
do {
if ((_tokenSet_8.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
access_mode();
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_STATIC) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(KW_STATIC);
inStaticCtxt = true;
}
else if ((LA(1)==KW_ABSTRACT) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
Aast tmp19_AST = null;
tmp19_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp19_AST);
match(KW_ABSTRACT);
}
else if ((LA(1)==KW_OVERRIDE) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
Aast tmp20_AST = null;
tmp20_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp20_AST);
match(KW_OVERRIDE);
}
else if ((LA(1)==KW_FINAL) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
Aast tmp21_AST = null;
tmp21_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp21_AST);
match(KW_FINAL);
}
else {
break _loop126;
}
} while (true);
}
mtype=method_return();
cls_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_EXTENT) && (_tokenSet_9.member(LA(2)))) {
size=extent();
astFactory.addASTChild(currentAST, returnAST);
method_stmt_AST = (Aast)currentAST.root;
if (size == -1 || size > 0) method_stmt_AST.putAnnotation("extent", Long.valueOf(size));
}
else if ((_tokenSet_1.member(LA(1))) && (LA(2)==LPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
param_list_definition(true, false, true);
astFactory.addASTChild(currentAST, returnAST);
block_term();
astFactory.addASTChild(currentAST, returnAST);
method_stmt_AST = (Aast)currentAST.root;
int atype = (a_AST == null) ? KW_PUBLIC : a_AST.getType();
String mname = s_AST.getText();
// add the method to the current class def and annotate the root
// node with the method level annotations
sym.addObjectMethod(mname, mtype, atype, (st_AST != null), method_stmt_AST, cls_AST);
method_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = method_stmt_AST;
}
public final void constructor_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast constructor_stmt_AST = null;
Aast a_AST = null;
Token st = null;
Aast st_AST = null;
Aast cl_AST = null;
try { // for error handling
Aast tmp22_AST = null;
tmp22_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp22_AST);
match(KW_CONSTRUC);
{
_loop118:
do {
if ((_tokenSet_8.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
access_mode();
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_STATIC) && (_tokenSet_1.member(LA(2)))) {
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(KW_STATIC);
inStaticCtxt = true;
}
else {
break _loop118;
}
} while (true);
}
any_symbol_at_all();
cl_AST = (Aast)returnAST;
hide(cl_AST);
param_list_definition(true, false, true);
astFactory.addASTChild(currentAST, returnAST);
block_term();
astFactory.addASTChild(currentAST, returnAST);
constructor_stmt_AST = (Aast)currentAST.root;
int atype = (a_AST == null) ? KW_PUBLIC : a_AST.getType();
String mname;
if (st_AST != null)
{
mname = "static " + cl_AST.getText();
}
else
{
mname = cl_AST.getText();
}
// add the constructor to the current class def as a method and annotate the root
// node with the method level annotations
sym.addObjectMethod(mname, OO_METH_VOID, atype, (st_AST != null), constructor_stmt_AST, null);
constructor_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = constructor_stmt_AST;
}
/**
* Top-level program definition (and entry point) of a Progress 4GL external
* procedure. The only real purpose of this entry point is to create an
* artificial root node for the external procedure itself. Since there
* is no prediction or looping occurring, there will only ever be a single
* root node of an external procedure. This entry point is simply used
* for tree creation but no real parsing ever happens here. The real core
* implementation of the top-level parsing starts with {@link #block}.
*
* @return <code>true</code> if all tokens in the input stream have been
* processed and the next token is <code>EOF</code>, otherwise
* some unexpected or invalid combination caused the top-level
* processing to end prematurely and without warnings or errors.
*/
public final boolean external_proc() throws RecognitionException, TokenStreamException {
boolean complete = false;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast external_proc_AST = null;
Aast b_AST = null;
try { // for error handling
topLevelEntry = true;
block();
b_AST = (Aast)returnAST;
external_proc_AST = (Aast)currentAST.root;
// this rule doesn't consume EOF, so if we have properly parsed the
// entire file, then the next token *should* be EOF; test for this
// and return the result of the test to the caller
complete = (LA(1) == EOF);
external_proc_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST));
external_proc_AST.putAnnotation("builtin-cls", builtInCls);
external_proc_AST.putAnnotation("dotnet-cls", dotNetCls);
currentAST.root = external_proc_AST;
currentAST.child = external_proc_AST!=null &&external_proc_AST.getFirstChild()!=null ?
external_proc_AST.getFirstChild() : external_proc_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = external_proc_AST;
return complete;
}
/**
* This is the primary top-level rule that recursively handles Progress 4GL
* source files. Note that these source files <b>must</b> be already
* preprocessed (Progress 4GL Preprocessor statements are not handled by
* this parser).
* <p>
* The core top-level processing is actually in {@link #single_block} which
* is the rule that matches a one and only one top-level alternative. By
* separating the alternatives from this top-level rule, it is possible to
* implement recursive calls that only accept a single block, statement or
* assignment. The <code>THEN or ELSE</code> clauses in an <code>IF</code>
* language statement is an example of this requirement. Other places in the
* code that require a match to multiple blocks, statements and assignments
* must call this rule which implements 0 or more matches to the
* <code>single_block</code>. This rule implements the looping and the
* <code>single_block</code> implements the matching.
* <p>
* This rule loops until end of input which makes it ideal for processing an
* entire external procedure (see {@link #external_proc}). This rule will
* match a top-level alternative iteratively occurs until there are no more
* tokens to process, in which case it returns to its caller.
* <p>
* Note that there are spurious ambiguity warnings generated for this rule,
* due to the fact that many of the language constructs are simply ambiguous
* by design. This ambiguity is resolved by ordering (precedence), token
* rewriting and semantic predicates in the lower level rules. For this
* reason we disable ambiguity warnings.
* <p>
* This rule is also used as an entry point for {@link #procedure},
* {@link #function} and {@link #inner_block} which allows each of these
* rules to contain nested blocks by using recursion. Note that the fact
* that procedure and function definitions cannot be nested is handled by
* semantic predicates in the <code>procedure</code> and
* <code>function</code> rules respectively.
*/
public final void block() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast block_AST = null;
try { // for error handling
{
_loop18:
do {
if (((_tokenSet_10.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != EOF && LA(1) != KW_END )) {
single_block(false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop18;
}
} while (true);
}
block_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = block_AST;
}
/**
* Top-level program definition (and entry point) of a code block handling a dynamic find/query. It is
* created so that the resulted tree is the same as for a full {@code external_proc()} call but it does
* supported only a limited set of statements.
* Only the following cases/statements are supported:
* 1. Dynamic find query:
* FIND FIRST <buffer> <find-predicate> <lock-type>.
*
* 2. Dynamic query prepare:
* [ DEFINE BUFFER <buff-name> FOR [TEMP-TABLE] <table-name>. ]*
* OPEN QUERY DynGenQuery <query-predicate>.
* In the future, if other statements will be supported, they will have to be added to
* {@code dynamic_query_stmt}.
*/
public final void dynamic_query_proc() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_query_proc_AST = null;
Aast db_AST = null;
try { // for error handling
topLevelEntry = true;
dynamic_query_block();
db_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
dynamic_query_proc_AST = (Aast)currentAST.root;
dynamic_query_proc_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"dynamic-block")).add(db_AST));
currentAST.root = dynamic_query_proc_AST;
currentAST.child = dynamic_query_proc_AST!=null &&dynamic_query_proc_AST.getFirstChild()!=null ?
dynamic_query_proc_AST.getFirstChild() : dynamic_query_proc_AST;
currentAST.advanceChildToEnd();
dynamic_query_proc_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = dynamic_query_proc_AST;
}
/**
* Processes a set of statements inside a dynamic program. Called only from {@code dynamic_query_proc}.
*/
public final void dynamic_query_block() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_query_block_AST = null;
try { // for error handling
{
_loop12:
do {
if ((LA(1)==KW_DEFINE||LA(1)==KW_FIND||LA(1)==KW_OPEN)) {
dynamic_query_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop12;
}
} while (true);
}
dynamic_query_block_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = dynamic_query_block_AST;
}
/**
* Identifies one of the three known statements to the {@code dynamic_query_proc} and dispatches the call
* to the appropriate rule. Puts the resulting sub-tree in a {@code STATEMENT} AST node and sets the
* text accordingly.
*/
public final void dynamic_query_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_query_stmt_AST = null;
Aast f_AST = null;
Aast ddb_AST = null;
Aast oq_AST = null;
try { // for error handling
switch ( LA(1)) {
case KW_FIND:
{
find_stmt();
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
dynamic_query_stmt_AST = (Aast)currentAST.root;
dynamic_query_stmt_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(STATEMENT,"dynamic-find-stmt")).add(f_AST));
currentAST.root = dynamic_query_stmt_AST;
currentAST.child = dynamic_query_stmt_AST!=null &&dynamic_query_stmt_AST.getFirstChild()!=null ?
dynamic_query_stmt_AST.getFirstChild() : dynamic_query_stmt_AST;
currentAST.advanceChildToEnd();
dynamic_query_stmt_AST = (Aast)currentAST.root;
break;
}
case KW_DEFINE:
{
dynamic_define_buffer_stmt();
ddb_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
dynamic_query_stmt_AST = (Aast)currentAST.root;
dynamic_query_stmt_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(STATEMENT,"dynamic-create-buffer")).add(ddb_AST));
currentAST.root = dynamic_query_stmt_AST;
currentAST.child = dynamic_query_stmt_AST!=null &&dynamic_query_stmt_AST.getFirstChild()!=null ?
dynamic_query_stmt_AST.getFirstChild() : dynamic_query_stmt_AST;
currentAST.advanceChildToEnd();
dynamic_query_stmt_AST = (Aast)currentAST.root;
break;
}
case KW_OPEN:
{
open_query_stmt();
oq_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
dynamic_query_stmt_AST = (Aast)currentAST.root;
dynamic_query_stmt_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(STATEMENT,"dynamic-open-query-stmt")).add(oq_AST));
currentAST.root = dynamic_query_stmt_AST;
currentAST.child = dynamic_query_stmt_AST!=null &&dynamic_query_stmt_AST.getFirstChild()!=null ?
dynamic_query_stmt_AST.getFirstChild() : dynamic_query_stmt_AST;
currentAST.advanceChildToEnd();
dynamic_query_stmt_AST = (Aast)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_12);
}
returnAST = dynamic_query_stmt_AST;
}
/**
* Matches the <code>FIND</code> language statement and implements all
* forms with most of the core processing delegated to the
* {@link #record_phrase} rule.
* <p>
* Note that one option <code>CURRENT</code> allows more possible record
* phrase options than are actually valid in Progress, however it is
* simply a superset of the valid options and as such is safe.
* <p>
* There is inherent ambiguity here with the use of unreserved Progress
* keywords <code>PREV, LEFT and OUTER-JOIN</code> that is detected by
* ANTLR. The code has been reviewed and the conflicting cases either
* can't occur in valid Progress code or they will be properly resolved
* anyway. For this reason, ambiguity warnings are disabled.
*/
public final void find_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast find_stmt_AST = null;
try { // for error handling
Aast tmp23_AST = null;
tmp23_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp23_AST);
match(KW_FIND);
{
switch ( LA(1)) {
case KW_FIRST:
{
Aast tmp24_AST = null;
tmp24_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp24_AST);
match(KW_FIRST);
break;
}
case KW_LAST:
{
Aast tmp25_AST = null;
tmp25_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp25_AST);
match(KW_LAST);
break;
}
case KW_NEXT:
{
Aast tmp26_AST = null;
tmp26_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp26_AST);
match(KW_NEXT);
break;
}
case KW_CURRENT:
{
Aast tmp27_AST = null;
tmp27_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp27_AST);
match(KW_CURRENT);
break;
}
default:
if ((LA(1)==KW_PREV) && (_tokenSet_13.member(LA(2))) && (_tokenSet_14.member(LA(3)))) {
Aast tmp28_AST = null;
tmp28_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp28_AST);
match(KW_PREV);
}
else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
record_phrase(false, false);
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
find_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = find_stmt_AST;
}
/**
* Identifies and process a definition of a buffer in a dynamic environment. It seems like the {@code DOT} at
* end of the statement is not matched automatically so it is expressly dropped if encountered after
* processing the buffer definition.
*/
public final void dynamic_define_buffer_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_define_buffer_stmt_AST = null;
Token d = null;
Aast d_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DEFINE);
def_buf_stmt(true, false, false, null, null);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BUFFER);
{
switch ( LA(1)) {
case DOT:
{
match(DOT);
break;
}
case EOF:
case KW_DEFINE:
case KW_FIND:
case KW_OPEN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
dynamic_define_buffer_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_12);
}
returnAST = dynamic_define_buffer_stmt_AST;
}
/**
* Matches a <code>OPEN QUERY</code> language statement and all possible
* options. Uses:
* <p>
* <ul>
* <li> {@link #malformed_symbol}
* <li> {@link #for_or_preselect_clause}
* <li> {@link #max_rows_clause}
* <li> {@link #collate_clause}
* <li> {@link #by_clause}
* <li> {@link #query_tuning_phrase}
* </ul>
* <p>
* Used by {@link #stmt_list}.
*/
public final void open_query_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast open_query_stmt_AST = null;
Token o = null;
Aast o_AST = null;
Token qk = null;
Aast qk_AST = null;
Aast q_AST = null;
try { // for error handling
o = LT(1);
o_AST = (Aast)astFactory.create(o);
astFactory.makeASTRoot(currentAST, o_AST);
match(KW_OPEN);
o_AST.setType(OPEN_QUERY);
qk = LT(1);
qk_AST = (Aast)astFactory.create(qk);
match(KW_QUERY);
hide(qk);
malformed_symbol();
q_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
q_AST.setType(QUERY);
for_or_preselect_clause();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1210:
do {
switch ( LA(1)) {
case KW_IDX_REPO:
{
Aast tmp30_AST = null;
tmp30_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp30_AST);
match(KW_IDX_REPO);
break;
}
case KW_BREAK:
{
Aast tmp31_AST = null;
tmp31_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp31_AST);
match(KW_BREAK);
sym.endIndexFieldSearch();
break;
}
case KW_MAX_ROWS:
{
max_rows_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BY:
case KW_COLLATE:
{
{
switch ( LA(1)) {
case KW_COLLATE:
{
collate_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BY:
{
sort_order_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_QRY_TUNE:
{
query_tuning_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1210;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
sym.endIndexFieldSearch();
if (sym.lookupQuery(q_AST.getText()) != QUERY)
{
// if the query is not yet defined, define it now
sym.addQuery(q_AST.getText(), q_AST, QUERY, null, null);
}
open_query_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = open_query_stmt_AST;
}
/**
* Matches a <code>DEFINE BUFFER</code> Progress 4GL language statement.
* This is the statement that defines or imports new user-named buffers and
* associates these with a specific database table, temp-table or
* work-table.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* buffers. This rule supports shared or local buffers and the syntax for
* both declaring or defining (<code>NEW</code> keyword) shared buffers.
* HOWEVER, all the matching for these optional keywords is done in the
* <code>define_stmt</code> rule. This refactoring allows all
* <code>DEFINE</code> statements to be supported without ambiguity.
* <p>
* This rule matches the <code>BUFFER</code> keyword and all subsequent
* processing. Note that due to syntax compatibility, this rule is also
* called from {@link #def_parm_stmt} and {@link #parameter} which allows
* this logic to be centralized. The following <code>FOR</code> construct
* is only optional to support the call from the <code>parameter</code>
* rule when it is processing a <code>RUN</code> statement parameter. When
* the <code>parameter</code> rule is processing a <code>FUNCTION</code>
* parameter, the <code>FOR</code> processing will be matched (if the code
* is valid Progress 4GL). Anytime the <code>FOR</code> processing is matched,
* this means that this is a new or imported buffer definition and the
* buffer will be added to the schema namespace.
* <p>
* This supports an undocumented Progress feature where function parameters
* can be specified without the symbolic name (e.g. in a forward function
* declaration it can look like <code>BUFFER FOR record</code>).
*
* @param define_stmt
* If <code>true</code>, this rule has been called from the
* <code>DEFINE BUFFER</code> statement and the
* <code>KW_BUFFER</code> node should be dropped (it is
* unnecessary). If <code>false</code>, the caller is some form
* of parameter processing and the <code>KW_BUFFER</code> node is
* used as the resulting sub-tree root.
* @param optionalSym
* If <code>true</code>, this rule has been called from a function
* parameter and the buffer's symbolic name is optional.
* @param importedShared
* If <code>true</code>, this definition is a non-new shared variable which is the
* equivalent of a FIND or CREATE. This means we must promote the buffer name now
* so that it can disambiguate references within this scope.
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
*/
public final void def_buf_stmt(
boolean define_stmt, boolean optionalSym, boolean importedShared, Aast am, Aast st
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_buf_stmt_AST = null;
Token buf = null;
Aast buf_AST = null;
Aast b_AST = null;
try { // for error handling
String rtext = null;
{
{
if (((LA(1)==KW_BUFFER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( define_stmt )) {
buf = LT(1);
buf_AST = (Aast)astFactory.create(buf);
match(KW_BUFFER);
hide(buf);
}
else if ((LA(1)==KW_BUFFER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp32_AST = null;
tmp32_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp32_AST);
match(KW_BUFFER);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((_tokenSet_15.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
symbol();
b_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( optionalSym )) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_FOR) && (_tokenSet_13.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
rtext=simple_for_record_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop210:
do {
if ((LA(1)==KW_PRESEL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp33_AST = null;
tmp33_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp33_AST);
match(KW_PRESEL);
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_XML_NNAM) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
xml_node_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SERIALZN) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NAMESP_P||LA(1)==KW_NAMESP_U) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
namespace_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop210;
}
} while (true);
}
}
if (b_AST != null && rtext != null)
{
boolean forceTemp = false;
AST ns = b_AST.getNextSibling();
if (ns != null && ns.getType() == KW_FOR)
{
AST a = ns.getFirstChild();
if (a != null && a.getType() == KW_TEMP_TAB)
{
forceTemp = true;
}
}
if (SymbolResolver.isPreScan() && rtext.equalsIgnoreCase(b_AST.getText()))
{
// in pre-scan mode, leave only the 'default' buffer and do not allow override with the same name.
// this 'DEFINE BUFFER b1 FOR b1' statement is possible only for temp-table buffers; for permanent
// buffers, you can't redefine an already defined 'b1' buffer.
}
else
{
if (!defineBufferFromSymbol(b_AST, rtext, am, st, forceTemp, false))
{
// fallback to physical table, if no temp-table is found.
defineBufferFromSymbol(b_AST, rtext, am, st, false, true);
}
// imported (non-new) shared buffers are the equivalent of a FIND or CREATE, we must
// promote these buffers to ensure proper name disambiguation
if (importedShared || !define_stmt)
{
// not sure about the noProp flag here
sym.promoteTableName(b_AST.getText(), true, false);
}
}
}
def_buf_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_buf_stmt_AST;
}
/**
* This rule implements the core matching of the top-level language
* constructs. It is called by {@link #block} which is a top-level entry
* point for processing an external procedure as well as the recursively
* called entry points for implementing nesting. This rule is also called
* directly from any parser location that needs to implement a match for
* any single procedure, class definition, function, trigger, block, statement
* or assignment. The key here is that this rule does not loop. It matches
* one of the 13 top-level constructs and then returns. This makes it ideal
* to handle the <code>THEN or ELSE</code> clauses in an <code>IF</code>
* language statement.
* <p>
* There are 13 possible alternatives for a top-level Progress language
* construct:
* <ul>
* <li> {@link #procedure} (definition) - rooted at a
* <code>PROCEDURE</code> node
* <li> {@link #class_def} (definition) - rooted at a
* <code>CLASS_DEF</code> node
* <li> {@link #interface_def} (definition) - rooted at an
* <code>INTERFACE_DEF</code> node
* <li> {@link #enum_def} (definition) - rooted at an
* <code>ENUM_DEF</code> node
* <li> {@link #constructor} (definition) - rooted at an
* <code>CONSTRUCTOR</code> node
* <li> {@link #destructor} (definition) - rooted at an
* <code>DESTRUCTOR</code> node
* <li> {@link #user_defined_method} (definition) - rooted at an
* <code>METHOD_DEF</code> node
* <li> trigger (definition) - rooted at a <code>TRIGGER_BLOCK</code> node
* <li> {@link #function} (forward declaration or definition) - rooted at
* a <code>FUNCTION</code> node
* <li> {@link #inner_block} (DO, REPEAT or FOR) - rooted at an
* <code>INNER_BLOCK</code> node
* <li> other language {@link #statement} - rooted at a
* <code>STATEMENT</code> node
* <li> directly embedded SQL processed by the {@link #statement} rule -
* rooted at an <code>EMBEDDED_SQL</code> node
* <li> {@link #assignment} - rooted at an <code>ASSIGNMENT</code> node
* <li> {@link #oea_annotations} - rooted at an <code>AT</code> node
* </ul>
* <p>
* <b>Trigger support is implemented as the {@link #on_stmt} which is
* matched as a language statement in the <code>statement</code> rule.</b>
* So while this rule can return a <code>TRIGGER_BLOCK</code>, this is not
* possible from the true top level of a Progress program (even though
* Progress seems to consider triggers as top-level constructs), this parser
* will match such constructs through <code>on_stmt</code>.
* <p>
* The order of evaluation is very important. Of special significance is the
* fact that assignments are processed last (have the lowest precedence).
* This is important since the leftmost token of an assignment is an optional
* <code>lvalue</code> which could be a variable or field with a name that
* matches an unreserved keyword. Since the lexer is biased toward setting
* token types to a keyword when there are conflicts, ambiguity is removed by
* allowing all the keyword processing to occur first and then overriding the
* token type with a variable, field or function type.
* <p>
* When entered, this rule predicts a match based on the 2 lookahead tokens
* and the rolled up prediction sets from each alternative, it calls the
* alternative which matches and consumes all tokens so described by the
* rules and the tree of rules which can be reached from the top-level
* alternative. At that point, the flow of control returns back to this
* method and this method returns to its caller.
* <p>
* In ANTLR, any rule references that impact the leftmost k tokens (where
* k is the lookahead depth) cause a vertical 'rollup' of all possible sets
* of leftmost tokens. Rollup refers to the aggregation of possibilities
* from called rules into a set (often a BitSet) that can be checked against
* lookahead token 1, a 2nd set that can be checked against lookahead token
* 2 etc... The core problem is that ANTLR's rollup mechanism is not
* sophisticated enough to detect the <b>dependencies</b> between the sets.
* This means that a rule reference that should only be called with a very
* specific, ordered pair of tokens (e.g. X and Y) might end up matching
* when A, Y or X, B are encountered in the token stream, depending on the
* grammar. Even though the grammer encodes these dependencies, they are
* not considered when the top-level prediction logic is written. This leads
* false positives that would never normally be possible in the grammar. To
* resolve these ambiguities, the following techniques are used:
* <ul>
* <li> proper ordering of alternatives to put more specific matches
* before more general matches
* <li> token type rewriting in called rules (based on context) to
* ensure that:
* <ul>
* <li> more generic token types like <code>SYMBOL</code> can be
* matched against more specific requirements
* <li> more specific token types (like unreserved keywords) are
* matched by other possible token types that have lower
* precedence but would normally still be possible depending on
* context
* </ul>
* <li> semantic predicates are used to add specific, targeted tests into
* top level rules wherever the predictive logic is too broad
* (eliminating the false positive by limiting the matches to the
* strict set of possible matches based on the dependencies)
* </ul>
* <p>
* These tricks don't stop ANTLR from detecting the ambiguity but as long as
* the grammar author inspects the resulting generated code and runs tests
* to provide there is no ambiguity, then it is proper to disable the ANTLR
* ambiguity warnings.
* <p>
* At this time, the rule is structured such that ANTLR properly predicts
* the difference between a <code>procedure</code> keyword that is being
* followed by a colon and thus is a label (the optional beginning of a
* do, repeat or for block) versus the use of the <code>procedure</code>
* keyword that starts a procedure definition (and must be followed by a
* symbol which is the procedure name). It can do the same with the
* <code>function</code> keyword. There is no ambiguity due to this.
* <p>
* A semantic predicate is used here to force the prediction for an inner
* block to be more narrow than ANTLR would generate on its own. This
* avoids some mistaken matches. In addition to the more specific prediction,
* this rule needs to check whether the colon that is possibly signifying
* a label was followed by whitespace or not. This is needed to differentiate
* between labels (which must always be followed by whitespace) and
* attributes/methods where the colon cannot be followed by whitespace.
* This part of the test relies upon the lexer to store an extra space after
* the colon (in the token's text itself) if there was any kind of following
* whitespace. Only the lexer can do that because the whitespace is
* discarded before the parser encounters it (changing that is just not
* feasible). So this approach is lame but it is better than the alternative
* (which is to allow the {@link ProgressLexer#mSYMBOL} rule to consume
* embedded colons and force the parser to split up the combined token into
* its constituent parts. See {@link #primary_expr} which is the rule that
* should be matched if the label's colon does not have following whitespace.
* <p>
* What makes this rule (and any looping calling rule like <code>block</code>)
* work is that the <code>END</code> keyword cannot EVER be matched in the
* leftmost token position. This allows each nested block to end when such
* a construct is encountered, which allows the calling rule to return or
* to consume the <code>END</code> and then return.
*
* @param blockRoot
* If <code>true</code>, root all child nodes at an artificial
* <code>BLOCK</code> node.
* @param trigger
* If <code>true</code> then the result will be rooted at a node
* of type <code>TRIGGER_BLOCK</code>. Ignored if
* <code>blockRoot</code> is <code>false</code>.
*/
public final void single_block(
boolean blockRoot, boolean trigger
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast single_block_AST = null;
Aast c_AST = null;
try { // for error handling
isUserDefFunctionCall(LT(1), LT(2));
int typ1 = LA(1);
int typ2 = LA(2);
boolean blk = (typ1 == KW_DO || typ1 == KW_REPEAT || typ1 == KW_FOR);
boolean proper = false;
boolean mal = false;
Aast malformedLabel = null;
boolean bypassStatement = false;
boolean inputFunc = (typ1 == KW_INPUT &&
(typ2 != KW_CLEAR && typ2 != KW_STREAM && typ2 != KW_STRM_HND &&
typ2 != KW_CLOSE && typ2 != KW_FROM && typ2 != KW_THROUGH));
// for every stmt or other feature used in a constructor, increment the counter
if (constStmts > -1)
{
constStmts++;
}
if (!blk)
{
// not an unlabeled inner block, check for a possible label
proper = isProperLabel(typ1);
if (!proper)
{
// not a proper label, check for a malformed label
mal = isMalformedLabel(true, 1, null);
// HARD CODED call that can't be placed directly in our rule
// below (inner_block) without very bad results on prediction
// logic generation
if (mal)
{
malformed_symbol();
malformedLabel = (Aast)returnAST;
colon();
}
}
}
if ((typ1 == KW_BLK_LVL && typ2 != KW_ON) ||
(typ1 == KW_CATCH && typ2 != SYMBOL) ||
typ1 == KW_CHOOSE ||
(typ1 == KW_CLOSE && typ2 != SYMBOL) ||
(typ1 == KW_COMPILE && typ2 != STRING
&& typ2 != KW_VALUE
&& typ2 != FILENAME) ||
(typ1 == KW_CONN && typ2 != STRING
&& typ2 != KW_VALUE
&& typ2 != FILENAME) ||
(typ1 == KW_EMPTY && typ2 != KW_TEMP_TAB) ||
(typ1 == KW_FINALLY && typ2 != COLON) ||
(typ1 == KW_GET && typ2 != KW_FIRST
&& typ2 != KW_LAST
&& typ2 != KW_PREV
&& typ2 != KW_NEXT
&& typ2 != KW_CURRENT) ||
typ1 == KW_LOAD ||
typ1 == KW_OPENMIME ||
typ1 == KW_OPEN_URL ||
typ1 == KW_RAW_TRAN ||
(typ1 == KW_ROUTINEL && typ2 != KW_ON) ||
(typ1 == KW_STOP && typ2 != DOT) ||
typ1 == KW_SYS_HELP ||
(typ1 == KW_TRAN_MOD && typ2 != KW_AUTOMATC) ||
typ1 == KW_UNLOAD ||
typ1 == KW_USE ||
typ1 == KW_VALIDATE ||
typ1 == KW_WAIT)
{
String tok = LT(1).getText();
boolean varFollowingTyp2 = (typ2 == DOT ||
typ2 == EQUALS ||
typ2 == COLON ||
typ2 == LBRACKET ||
typ2 == DB_REF_NON_STATIC ||
isBinaryOp(typ2));
if ((sym.lookupVariable(tok) != -1 && varFollowingTyp2) ||
(sym.lookupFunction(tok) != -1 && typ2 == LPARENS) ||
(varFollowingTyp2 &&
(inStaticCtxt && sym.lookupDataMember(null, tok, true) != -1) ||
(!inStaticCtxt && sym.lookupDataMember(null, tok) != -1)) ||
(typ2 == LPARENS && sym.isObjectMethod(null, tok, inStaticCtxt)))
{
bypassStatement = true;
}
}
{
if ((LA(1)==KW_PROC) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
procedure();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CLASS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_16.member(LA(3)))) {
class_def();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_INTERFAC) && (_tokenSet_0.member(LA(2))) && (_tokenSet_17.member(LA(3)))) {
interface_def();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_ENUM) && (_tokenSet_0.member(LA(2))) && (_tokenSet_18.member(LA(3)))) {
enum_def();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CONSTRUC) && (_tokenSet_1.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
constructor();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DESTRUCT) && (_tokenSet_1.member(LA(2))) && (_tokenSet_5.member(LA(3)))) {
destructor();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_METHOD) && (_tokenSet_0.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
user_defined_method();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_FUNCT) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK)))&&( LA(1) == KW_FUNCT && (isSomeSymbol(LA(2)) || isMalformedSymbol(2)) )) {
function();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( blk || proper || mal )) {
inner_block(true, malformedLabel);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==DOT) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == DOT && (!followedByWhitespace(LT(1)) && LA(2) != EOF) )) {
crap_to_ignore();
c_AST = (Aast)returnAST;
hide(c_AST);
}
else if (((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(bypassStatement)) {
assignment();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_22.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!bypassStatement &&
!inputFunc &&
((LA(1) != KW_SUPER && LA(1) != KW_THIS_OBJ) || (constStmts > 0 && LA(2) == LPARENS)) &&
!isClassDereference(LT(1), LT(2))
)) {
statement();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !bypassStatement && isValidLeftmostReserved(LT(1), LT(2)) )) {
assignment();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==AT)) {
oea_annotations();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==UNKNOWN_TOKEN) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( false )) {
{
Aast tmp34_AST = null;
tmp34_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp34_AST);
match(UNKNOWN_TOKEN);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
single_block_AST = (Aast)currentAST.root;
// when used in if/then/else or case/when/then/otherwise, this
// rule can match a single statement or assignment, however this
// flag specifies to root such statements or assignments at an
// artificial block node to aid at conversion time
if (blockRoot && single_block_AST != null)
{
int stype = single_block_AST.getType();
int ttype = TRIGGER_BLOCK;
String ttxt = "trigger block";
// we don't expect function or procedure definitions here and
// we MUST exclude inner_block definitions since these are
// already rooted properly
if (stype == STATEMENT || stype == ASSIGNMENT || stype == EMBEDDED_SQL)
{
single_block_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(single_block_AST));
if (trigger)
{
// for simple STATEMENTs or ASSIGNMENTs, we previously
// created a BLOCK root node, now this will be placed
// under a TRIGGER_BLOCK
single_block_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(ttype,ttxt)).add(single_block_AST));
}
}
else if (stype == INNER_BLOCK)
{
if (trigger)
{
// this is the case where there is a group of statements
// enclosed in a DO block (REPEAT and FOR cannot be used,
// even the DO block itself MUST be unqualified) so we
// override the type and text since this isn't a real
// innerblock
saveAndReplaceTypeAndText(single_block_AST, ttype, ttxt);
}
}
}
currentAST.root = single_block_AST;
currentAST.child = single_block_AST!=null &&single_block_AST.getFirstChild()!=null ?
single_block_AST.getFirstChild() : single_block_AST;
currentAST.advanceChildToEnd();
single_block_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = single_block_AST;
}
/**
* This rule creates the block structure for a procedure. All procedure
* definitions must start with the <code>PROCEDURE</code> language statement
* (see {@link #proc_stmt}). This is followed by a recursive call to
* {@link #block} which handles the ability to nest top-level statements
* inside a procedure. Finally, the rule ends with an optional
* <code>END</code> language statement. The Progress language states that it
* is valid to not have and <code>END</code>. In this case, the procedure's
* end is implicit at the end of the file.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when there is any attempt to nest
* procedure or function definitions (which is not allowed). The
* semantic predicate is used here instead of using the parser
* structure itself (the manner in which the rules call each other)
* since the ability to properly nest blocks is dependent upon the
* structure as implemented. Any other approach limited the nesting
* in a manner that was more restrictive than the Progress language
* itself.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #function} and
* {@link #class_def} rules (among others).
* <p>
* Called by {@link #single_block}.
*/
public final void procedure() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast procedure_AST = null;
Aast p_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
bufferScope = false;
{
proc_stmt();
p_AST = (Aast)returnAST;
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
procedure_AST = (Aast)currentAST.root;
procedure_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(PROCEDURE,"procedure")).add(p_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
// internal procedure and function definitions cannot be nested in
// each other or within themselves, so whenever this exits the
// buffer scope can be safely set to global
bufferScope = true;
// internal procedures propagate
sym.deleteSchemaScope(true);
sym.deleteScope();
nestLevel--;
currentAST.root = procedure_AST;
currentAST.child = procedure_AST!=null &&procedure_AST.getFirstChild()!=null ?
procedure_AST.getFirstChild() : procedure_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = procedure_AST;
}
/**
* This rule creates the block structure for a class definition. All class
* definitions must start with the {@link #class_stmt}. This is followed by
* a recursive call to {@link #block} which handles the ability to nest
* top-level statements inside a class definition. Finally, the rule ends
* with an <code>END</code> language statement.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when there is any attempt to nest
* procedure or function definitions (which is not allowed). The
* semantic predicate is used here instead of using the parser
* structure itself (the manner in which the rules call each other)
* since the ability to properly nest blocks is dependent upon the
* structure as implemented. Any other approach limited the nesting
* in a manner that was more restrictive than the Progress language
* itself.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure},
* {@link #interface_def}, {@link #function} and other top-level blocks.
* <p>
* Called by {@link #single_block}.
*/
public final void class_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast class_def_AST = null;
Aast c_AST = null;
Aast b_AST = null;
try { // for error handling
insideClass = true;
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
// treat class definitions like external procedures, don't force bufferScope to false
{
class_stmt();
c_AST = (Aast)returnAST;
if (!( nestLevel < 2 ))
throw new SemanticException(" nestLevel < 2 ");
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
class_def_AST = (Aast)currentAST.root;
class_def_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(CLASS_DEF,"class definition")).add(c_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
// don't know if class defs propagate, assume true for now
sym.deleteSchemaScope(true);
sym.deleteScope();
nestLevel--;
sym.classDefinitionComplete();
insideClass = false;
currentAST.root = class_def_AST;
currentAST.child = class_def_AST!=null &&class_def_AST.getFirstChild()!=null ?
class_def_AST.getFirstChild() : class_def_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = class_def_AST;
}
/**
* This rule creates the block structure for an interface definition. All
* interface definitions must start with the {@link #interface_stmt}.
* This is followed by a recursive call to {@link #block} which handles
* the ability to nest top-level statements inside an interface. Finally,
* the rule ends with an <code>END</code> language statement.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when there is any attempt to nest
* procedure or function definitions (which is not allowed). The
* semantic predicate is used here instead of using the parser
* structure itself (the manner in which the rules call each other)
* since the ability to properly nest blocks is dependent upon the
* structure as implemented. Any other approach limited the nesting
* in a manner that was more restrictive than the Progress language
* itself.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure}, {@link #class_def}
* {@link #function} and other top-level blocks.
* <p>
* Called by {@link #single_block}.
*/
public final void interface_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast interface_def_AST = null;
Aast i_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
// treat class definitions like external procedures, don't force bufferScope to false
{
interface_stmt();
i_AST = (Aast)returnAST;
if (!( nestLevel < 2 ))
throw new SemanticException(" nestLevel < 2 ");
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
interface_def_AST = (Aast)currentAST.root;
interface_def_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(INTERFACE_DEF,"interface definition")).add(i_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
// don't know if interfaces propagate, assume true for now
sym.deleteSchemaScope(true);
sym.deleteScope();
nestLevel--;
sym.classDefinitionComplete();
currentAST.root = interface_def_AST;
currentAST.child = interface_def_AST!=null &&interface_def_AST.getFirstChild()!=null ?
interface_def_AST.getFirstChild() : interface_def_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = interface_def_AST;
}
/**
* This rule creates the block structure for an enum definition. All
* enum definitions must start with the {@link #enum_stmt}.
* This is followed by a recursive call to {@link #block} which handles
* the ability to nest multiple DEFINE ENUM statements inside the enum. Finally,
* the rule ends with an <code>END</code> language statement.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when there is any attempt to nest
* procedure or function definitions (which is not allowed). The
* semantic predicate is used here instead of using the parser
* structure itself (the manner in which the rules call each other)
* since the ability to properly nest blocks is dependent upon the
* structure as implemented. Any other approach limited the nesting
* in a manner that was more restrictive than the Progress language
* itself.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure}, {@link #class_def}
* {@link #function} and other top-level blocks.
* <p>
* Called by {@link #single_block}.
*/
public final void enum_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast enum_def_AST = null;
Aast e_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
// buffers and other db stuff can't be referenced inside an enum def
{
enum_stmt();
e_AST = (Aast)returnAST;
if (!( nestLevel < 2 ))
throw new SemanticException(" nestLevel < 2 ");
enum_stmt_body();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
enum_def_AST = (Aast)currentAST.root;
enum_def_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(ENUM_DEF,"enum definition")).add(e_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
sym.deleteScope();
nestLevel--;
sym.classDefinitionComplete();
currentAST.root = enum_def_AST;
currentAST.child = enum_def_AST!=null &&enum_def_AST.getFirstChild()!=null ?
enum_def_AST.getFirstChild() : enum_def_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = enum_def_AST;
}
/**
* This rule creates the block structure for a constructor definition. All
* interface definitions must start with the {@link #constructor_stmt}.
* This is followed by a recursive call to {@link #block} which handles
* the ability to nest top-level statements inside a constructor. Finally,
* the rule ends with an <code>END</code> language statement.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when this is not nested inside a
* class definition.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure}, {@link #class_def}
* {@link #interface_def}, {@link #destructor}, {@link #function} and other
* top-level blocks.
* <p>
* Called by {@link #single_block}.
*/
public final void constructor() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast constructor_AST = null;
Aast c_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
boolean oldBufScope = bufferScope;
bufferScope = false;
inMethodDef = true;
sym.setInMethod(true);
constStmts = 0;
{
constructor_stmt();
c_AST = (Aast)returnAST;
if (!( nestLevel == 2 ))
throw new SemanticException(" nestLevel == 2 ");
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
constructor_AST = (Aast)currentAST.root;
constructor_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(CONSTRUCTOR,"constructor")).add(c_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
constStmts = -1;
// constructors are always nested
bufferScope = oldBufScope;
inMethodDef = false;
sym.setInMethod(false);
// don't know if constructors propagate, assume true for now
sym.deleteSchemaScope(true);
sym.deleteScope();
nestLevel--;
inStaticCtxt = false;
currentAST.root = constructor_AST;
currentAST.child = constructor_AST!=null &&constructor_AST.getFirstChild()!=null ?
constructor_AST.getFirstChild() : constructor_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = constructor_AST;
}
/**
* This rule creates the block structure for a destructor definition. All
* interface definitions must start with the {@link #destructor_stmt}.
* This is followed by a recursive call to {@link #block} which handles
* the ability to nest top-level statements inside a destructor. Finally,
* the rule ends with an <code>END</code> language statement.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when this is not nested inside a
* class definition.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure}, {@link #class_def}
* {@link #interface_def}, {@link #constructor}, {@link #function} and other
* top-level blocks.
* <p>
* Called by {@link #single_block}.
*/
public final void destructor() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast destructor_AST = null;
Aast d_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
boolean oldBufScope = bufferScope;
bufferScope = false;
inMethodDef = true;
sym.setInMethod(true);
{
destructor_stmt();
d_AST = (Aast)returnAST;
if (!( nestLevel == 2 ))
throw new SemanticException(" nestLevel == 2 ");
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
destructor_AST = (Aast)currentAST.root;
destructor_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(DESTRUCTOR,"destructor")).add(d_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
// destructors are always nested
bufferScope = oldBufScope;
inMethodDef = false;
sym.setInMethod(false);
// don't know if destructors propagate, assume true for now
sym.deleteSchemaScope(true);
sym.deleteScope();
nestLevel--;
currentAST.root = destructor_AST;
currentAST.child = destructor_AST!=null &&destructor_AST.getFirstChild()!=null ?
destructor_AST.getFirstChild() : destructor_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = destructor_AST;
}
/**
* This rule creates the block structure for a user defined method. All
* method definitions must start with the {@link #method_stmt}. If this
* is a class definition rather than an interface definition, then this is
* followed by a recursive call to {@link #block} which handles the ability
* to nest top-level statements inside a method. If there is a block then
* the rule ends with an <code>END</code> language statement.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when this is not nested inside a
* class definition.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure}, {@link #class_def}
* {@link #interface_def}, {@link #constructor}, {@link #destructor},
* {@link #function} and other top-level blocks.
* <p>
* Called by {@link #single_block}.
*/
public final void user_defined_method() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast user_defined_method_AST = null;
Aast m_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
boolean oldBufScope = bufferScope;
bufferScope = false;
inMethodDef = true;
sym.setInMethod(true);
boolean iface = sym.getCurrentClassDef().isInterface();
boolean abstr = false;
{
method_stmt();
m_AST = (Aast)returnAST;
if (!( nestLevel == 2 ))
throw new SemanticException(" nestLevel == 2 ");
abstr = (m_AST.getImmediateChild(KW_ABSTRACT, null) != null);
{
if (((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !iface && !abstr )) {
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
user_defined_method_AST = (Aast)currentAST.root;
// #b can be null here even when there is an empty block (just an END stmt following
// the block_term); we will create the block node unless it is an interface or
// abstract method since there must have at least been an empty block; without this
// the block node is missing which would require fixups later
Aast blk = (iface || abstr) ? null : (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST));
user_defined_method_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(METHOD_DEF,"method definition")).add(m_AST).add(blk));
user_defined_method_AST.putAnnotation("prototype", Boolean.valueOf(blk == null));
// methods are always nested
bufferScope = oldBufScope;
inMethodDef = false;
sym.setInMethod(false);
// don't know if methods propagate, assume true for now (since
// methods that have not return values act like internal procs
// and those that return values act like functions, there may be
// 2 different cases here)
sym.deleteSchemaScope(true);
sym.deleteScope();
inStaticCtxt = false;
nestLevel--;
currentAST.root = user_defined_method_AST;
currentAST.child = user_defined_method_AST!=null &&user_defined_method_AST.getFirstChild()!=null ?
user_defined_method_AST.getFirstChild() : user_defined_method_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = user_defined_method_AST;
}
/**
* This rule creates the block structure for a function or handles the case
* of a forward function declaration (without a block). All function
* definitions must start with the <code>FUNCTION</code> language statement.
* If this is not a forward declaration (identified by the use of the
* <code>FORWARD</code> keyword), then the <code>FUNCTION</code> statement
* is followed by a recursive call to {@link #block} which handles
* the ability to nest top-level statements inside a function. Finally,
* the rule ends with an optional <code>END</code> language statement. The
* Progress language states that it is valid to not have and <code>END</code>.
* In this case, the function's end is implicit at the end of the file.
* <p>
* The most important features of this rule are:
* <ul>
* <li> The use of the <code>nestLevel</code> member to track the current
* nesting level of the tree. This allows us to throw an exception
* (using a semantic predicate) when there is any attempt to nest
* procedure or function definitions (which is not allowed). The
* semantic predicate is used here instead of using the parser
* structure itself (the manner in which the rules call each other)
* since the ability to properly nest blocks is dependent upon the
* structure as implemented. Any other approach limited the nesting
* in a manner that was more restrictive than the Progress language
* itself.
* <li> At the beginning of this method, a scope is added to the variable
* dictionary (this is the only part of the symbol dictionary that
* is scope aware). At the end of this method, the current scope
* is removed. This allows the definition of local variables that
* hide variables of the same name in higher level scopes. Note that
* since functions and procedures cannot be nested, there is no need
* to use scopes in the respective namespaces for functions and
* procedures. Progress essentially implements a flat namespace for
* each of these respectively.
* <li> The subrule that implements the recursive call to
* <code>block</code> cannot be made optional (using ANTLR syntax)
* without introducing ambiguity. Instead, a trick is used to create
* the same result. The subrule is split into two alternatives:
* <ul>
* <li> the original call to <code>block</code> (with its optional
* <code>END</code> statement)
* <li> the empty alternative (no rule or token references)
* </ul>
* Most importantly, the choice between these alternatives is made
* using a semantic predicate which tests the return value from
* the {@link #func_stmt} rule. This return value is a boolean that
* is <code>true</code> only in the case where this is a forward
* declaration. This approach means that forward declarations cause
* no block to appear in the tree, but all other types of functions
* properly create the block as expected.
* <li> At the beginning of this method, a scope is added to the schema
* dictionary. In addition, a flag is set to indicate that the
* parser is currently inside an internal procedure. This flag is
* used during buffer creation (see {@link #def_buf_stmt}) to
* determine the proper scope in which to create the buffer. At the
* end of this method, the current scope is removed.
* </ul>
* <p>
* This rule is a peer alternative to {@link #procedure}.
* <p>
* Called by {@link #single_block}.
*/
public final void function() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast function_AST = null;
Aast f_AST = null;
Aast b_AST = null;
try { // for error handling
boolean fwd = false;
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
bufferScope = false;
{
fwd=func_stmt();
f_AST = (Aast)returnAST;
{
if (((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !fwd )) {
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
function_AST = (Aast)currentAST.root;
// #b can be null here even when there is an empty block (just an END stmt following
// the block_term); we will create the block node unless it is a fwd == true case
// since there must have at least been an empty block; without this the block node is
// missing which would require fixups later
Aast blk = (fwd) ? null : (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST));
function_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(FUNCTION,"function")).add(f_AST).add(blk));
// internal procedure and function definitions cannot be nested in
// each other or within themselves, so whenever this exits the
// buffer scope can be safely set to global
bufferScope = true;
// functions propagate
sym.deleteSchemaScope(true);
sym.deleteScope();
nestLevel--;
currentAST.root = function_AST;
currentAST.child = function_AST!=null &&function_AST.getFirstChild()!=null ?
function_AST.getFirstChild() : function_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = function_AST;
}
/**
* This rule creates the block structure for a Progress 4GL nestable block.
* The {@link #block_list} rule is called to start the block and this is
* followed by a recursive call to {@link #block} which handles
* the ability to nest top-level statements inside a block. Finally,
* the rule ends with an optional <code>END</code> language statement. The
* Progress language states that it is valid to omit the <code>END</code>.
* In this case, the block's end is implicit at the end of the file.
* <p>
* The <code>nestLevel</code> instance member is incremented at the entry to
* this rule and decremented on exit. This allows the proper enforcement of
* nesting limitations (procedures and functions cannot be nested, ever).
* <p>
* In front of any of these constructs is an optional user-defined label.
* The presence of this label is matched by the following <code>COLON</code>
* that <b>must precede</b> the Progress 4GL language statement that starts
* the block. The {@link #symbol} method is used to force the user-defined
* name to a <code>SYMBOL</code> token type. If matched, this symbol's text
* is added into the label namespace and the token type of the symbol is
* set to <code>LABEL</code>.
* <p>
* Schema record scopes are added before calling <code>block_list</code>
* based on lookahead. A scope is added in the case of
* <code>FOR, REPEAT and DO FOR</code> statements. In the case of
* <code>EDITING and normal DO</code> blocks, a scope is NOT added. If a
* scope was added, then it is removed in the exit action. This allows the
* proper pushing and popping of record scopes in the same way as Progress
* implements it. <b>Note that at this time, there is only a simple imitation
* of the implicit expansion of a record scope from one block to another.
* This is done by the {@link #record} rule by ALWAYS promoting a table to
* the current scope. A more complicated solution may be necessary but it is
* not yet known how much this is actually in use.</b>
* <p>
* This rule also creates an artificial node in the tree as the parent to
* all children of the block. This node is created as a token type of
* <code>INNER_BLOCK</code> if this is a <code>DO, FOR or REPEAT</code>
* block and as a <code>EDITING_BLOCK</code> if this is an editing block.
* <p>
* Called by {@link #single_block}.
*
* @param eat
* If <code>true</code>, this code will consume (and drop) a
* following <code>DOT</code> after the <code>END</code>.
* @param malformed
* If not <code>null</code>, this is a replacement for the match
* on a properly formed label but due to limits of branch prediction
* it had to be handled in the caller rather than here.
*/
public final void inner_block(
boolean eat, Aast malformed
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast inner_block_AST = null;
Aast s_AST = null;
Aast l_AST = null;
Aast b_AST = null;
try { // for error handling
// procedures and functions CAN be defined inside inner blocks
// so nestLevel should not be incremented here!
boolean labeled = false;
boolean delScope = false;
// the optional symbol section below will never trigger if this
// is non-null so we don't have to disambiguate there
if (malformed != null)
{
s_AST = malformed;
}
sym.addInnerBlockScope();
{
{
if ((_tokenSet_15.member(LA(1)))) {
symbol();
s_AST = (Aast)returnAST;
colon();
}
else if ((_tokenSet_23.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if (s_AST != null)
{
s_AST.setType(LABEL_DEF);
sym.addLabel(s_AST.getText(), LABEL);
labeled = true;
}
// this code must always process next (before block_list is
// called)
if ( (LA(1) == KW_FOR) || (LA(1) == KW_REPEAT) ||
(LA(1) == KW_DO && LA(2) == KW_FOR) )
{
delScope = true;
sym.addSchemaScope(false);
}
block_list();
l_AST = (Aast)returnAST;
block();
b_AST = (Aast)returnAST;
{
if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt(eat);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
inner_block_AST = (Aast)currentAST.root;
sym.deleteInnerBlockScope();
int ttype = INNER_BLOCK;
String ttxt = "inner block";
if (l_AST.getType() == KW_EDITING)
{
ttype = EDITING_BLOCK;
ttxt = "editing block";
}
inner_block_AST = (Aast)astFactory.make( (new ASTArray(4)).add((Aast)astFactory.create(ttype,ttxt)).add(s_AST).add(l_AST).add((Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST))));
// inner blocks propagate
if (delScope)
sym.deleteSchemaScope(true);
if (labeled)
sym.deleteLabel();
// procedures and functions CAN be defined inside inner blocks
// so nestLevel should not be decremented here!
currentAST.root = inner_block_AST;
currentAST.child = inner_block_AST!=null &&inner_block_AST.getFirstChild()!=null ?
inner_block_AST.getFirstChild() : inner_block_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = inner_block_AST;
}
/**
* Undocumented syntax found in working code that is ignored in Progress. Match a DOT followed
* by text with no intervening whitespace, then any amount of whitespace, text, numbers and
* ended by a terminating DOT. All of the matched tokens will be dropped.
* <p>
* The rules:
* <p>
* <ol>
* <li> must start with a DOT
* <li> must have a valid character immediately following the leading DOT without any
* intervening whitespace
* <li> valid characters are anything EXCEPT numbers, open curly braces, single, or double
* quote chars
* <li> after that any whitespace (inluding newlines), numbers or other text is matched
* until a following DOT
* <li> inclusion of unescaped single or double quote characters anywhere does not work
* properly but it doesn't cause an error (more testing will be needed to see how
* it responds)
* <li> unescaped opening curly braces cannot be embedded
* <li> can be at the beginning, middle or end of any line in the file, but must NOT be
* inside a statement or expression
* <li> this construct CANNOT be started by the ternminating DOT of a statement, it must
* stand on its own
* </ol>
* <p>
* For example:
* <p>
* <pre>
* .t y757565gfhvbm hgj lk hkudu09sd
*
* .
* .?/.,><;:~`\|][}&=+-_)(*^%@!$#.
* ./.
* ..FDFDFD.
* .......
* .SDSD....SDSD.
* .a......
* ..dd..ddd ...
* .,.
* .>.
* .<.
* .;.
* .:.
* .~.
* .`.
* .\.
* .|.
* .].
* .[.
* .}.
* .=.
* .+.
* .-.
* ._.
* .).
* .(.
* .*.
* .&.
* .^.
* .%.
* .@.
* .!.
* .$.
* .#.
* .~".
* .~{.
* .~'.
* .s89s.
* .hdhdhdgsgdhfdjfj.
* .w.
* .l87676.
* </pre>
*/
public final void crap_to_ignore() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast crap_to_ignore_AST = null;
try { // for error handling
Aast tmp35_AST = null;
tmp35_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp35_AST);
match(DOT);
{
_loop37:
do {
if (((LA(1)==DOT) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == DOT && !followedByWhitespace(LT(1)) )) {
Aast tmp36_AST = null;
tmp36_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp36_AST);
match(DOT);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK))) {
Aast tmp37_AST = null;
tmp37_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp37_AST);
matchNot(DOT);
}
else {
break _loop37;
}
} while (true);
}
Aast tmp38_AST = null;
tmp38_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp38_AST);
match(DOT);
crap_to_ignore_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = crap_to_ignore_AST;
}
/**
* Matches both forms of an assignment statement (explicit assignment to
* an <code>lvalue</code> and the alternate implicit discard of the
* expression's return value). More specifically, these two forms:
* <ul>
* <li> any <code>lvalue</code> followed by an <code>EQUALS</code> token
* and an expression (this is the traditional concept of an
* assignment - one which stores the expression result in a variable
* or field)
* <li> any valid expression that stands on its own, with no
* <code>lvalue</code> and no <code>EQUALS</code> operator (this
* is necessary to allow one to execute an arbitrary function and
* discard the result while any side effects of the function still
* occur)
* </ul>
* <p>
* Note that the second form is a bit odd compared to most languages since
* it is legal (though useless) to specify a standalone non-assignment
* expression that is not a function call (whose return value is discarded
* but which may have side effects that are useful). An example of a useless
* expression is a string token followed by a <code>DOT</code>. This is a
* valid expression and the Progress compiler and interpreter do not complain,
* however there are no side effects that have any useful benefits. The
* Progress environment is tolerant of these useless expressions.
* <p>
* When the first form is encountered, the <code>EQUALS</code> token type is
* rewritten as an <code>ASSIGN</code> token type. Saving this context is
* key to subsequent evaluation of an expression since the parser already
* has determined the exact operation to be processed (otherwise there would
* be ambiguity left behind in the resulting expression tree).
* <p>
* This rule is called from the top level {@link #single_block} and calls the
* {@link #lvalue} and {@link #expr} rules as needed. It also creates an
* artificial tree node (of the <code>ASSIGNMENT</code> token type) to
* contain the resulting tree.
* <p>
* Note that ANTLR reports ambiguity between this rule and the {@link #assign}
* rule. The ambiguity is resolved by the ordering of the top level rule
* placing the <code>ASSIGN</code> language statement (which is unambiguous)
* with higher precedence than the <code>assignment</code> rule. As long as
* the <code>assign</code> rule is only used by the <code>assign_stmt</code>
* rule, there is no real ambiguity. For this reason, ambiguity warnings
* are suppressed for this rule.
* <p>
* ANTLR detects ambiguity between this rule and <code>expr</code> because of
* the optional <code>lvalue</code> and <code>EQUALS</code> which conflict
* with lookahead choices for <code>expr</code>. What makes this OK is the
* fact that there is an implicit precedence in choosing <code>EQUALS</code>
* as an assignment operator over the equivalence operator. This makes the
* ambiguity resolve naturally. For this reason, ambiguity warnings
* are suppressed for this rule.
* <p>
* This rule really needs a syntactic predicate (but we can't use these, see
* the class overview for details) to work in all cases. The problem is
* that it inherently relies upon lookahead (of whether there is an
* <code>EQUALS</code> token in the 2nd position) to disambiguate between
* the optional <code>lvalue</code> + <code>EQUALS</code> AND a standalone
* expression. In practice, this works fine for the vast majority of cases,
* but it breaks down in the following cases:
* <p>
* <ul>
* <li> <b>an <code>lvalue</code> with > 1 token is standalone on a
* line</b> (e.g. <code>i[8].</code> which is 4 tokens plus the
* terminating <code>DOT</code>) --> note that as long as there
* actually IS an assignment on the right side of a complex
* (multi-token) <code>lvalue</code>, there would not be a problem!
* <li> <b>an <code>lvalue</code> based expression is used (no assignment)
* </b> (e.g. <code>queryHandle:prepare(someThing).</code> which is 6
* tokens plus the terminating <code>DOT</code> OR even simpler is
* <code>queryHandle:query-open.</code> which is only 3 tokens and
* a terminating <code>DOT</code>)
* <li> language statements that look like functions (and often have
* functions with matching names!) but act like lvalues (see
* {@link #assign_type_syntax_stmt_list} which is called indirectly
* via the <code>lvalue</code> rule)
* </ul>
* <p>
* All of these cases are resolved by matching the in the <code>lvalue</code>
* rule and instrumenting the following <code>EQUALS</code> to be bypassed
* if a <code>DOT or NO-ERROR</code> are encountered. This would mean that
* there is no following expression to match so in this case, the expression
* is bypassed too.
* <p>
* This approach also requires that the preceding <code>lvalue</code> be
* bypassed if a left parenthesis is found in the second token position
* (otherwise the <code>lvalue</code> would match the symbol in a function
* call but then it would bomb out at the parenthesis. <b>An exception to
* this 'parenthesis avoidance' approach is made for those language statements
* that look like function calls but act like lvalues. An explicit test for
* this situation bypasses the normal parenthesis avoidance mechanism.</b>
* <p>
* Another problem is disambiguation of the case where the <code>lvalue</code>
* is followed by an operator (that is not EQUALS). The ANTLR lookahead does
* not naturally disambiguate this case, so an extra test for operators is
* done, to avoid the assignment path in this case. The result is usually a
* useless expression whose evaluated result is discarded, but it is valid.
* <p>
* To implement all of this multiple disambiguating semantic predicates had
* to be carefully inserted, empty alternatives (sometimes triggering
* associated actions) were added and the tree building was modified.
* All-in-all this was a truly nasty solution.
*/
public final void assignment() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assignment_AST = null;
Token rv = null;
Aast rv_AST = null;
Aast e_AST = null;
Token k = null;
Aast k_AST = null;
try { // for error handling
boolean lstmt = false;
matchAssign = true;
if (isLstmt(LA(1)) && LA(2) == LPARENS)
{
lstmt = true;
}
// check for a 2nd token which is a binary operator following
// an lvalue; such a case is not an assignment and must flow down
// the standalone expression path (warning: EQUALS is deliberately
// excluded from this test since the precedence must be given to
// the EQUALS token that will be considered an ASSIGN operator)
if (isBinaryOp(LA(2)) || LA(1) == LPARENS)
{
matchAssign = false;
}
{
if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
{
if ((LA(1)==KW_NO_RET_V) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
rv = LT(1);
rv_AST = (Aast)astFactory.create(rv);
match(KW_NO_RET_V);
matchAssign = false;
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
e_AST = (Aast)returnAST;
}
else if ((LA(1)==DOT||LA(1)==KW_NO_ERROR) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
k = LT(1);
k_AST = (Aast)astFactory.create(k);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
assignment_AST = (Aast)currentAST.root;
if (lstmt)
{
assignment_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(STATEMENT,"statement")).add(e_AST).add(k_AST));
}
else
{
assignment_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(ASSIGNMENT,"assignment")).add(e_AST).add(k_AST));
}
skipExpression = false;
matchAssign = false;
currentAST.root = assignment_AST;
currentAST.child = assignment_AST!=null &&assignment_AST.getFirstChild()!=null ?
assignment_AST.getFirstChild() : assignment_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = assignment_AST;
}
/**
* This rule creates an artificial tree node for any non-block language
* statement (these are language statements that do not start or end
* blocks). The real work is delegated to {@link #stmt_list}.
* <p>
* The only real work this rule does is create the tree node in a standard
* manner. The resulting language statement's subtree is a child of the
* standard, artificial <code>STATEMENT</code> token type node except in
* the case of embedded SQL where the node type of <code>EMBEDDED_SQL</code>
* will be at the root.
* <p>
* Any statement that generates a <code>null</code> return AST (the only
* one is {@link #empty_stmt} at this time), will bypass the creation of
* the artificial <code>STATEMENT</code> root node.
* <p>
* Called by {@link #single_block}.
*/
public final void statement() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast statement_AST = null;
Aast s_AST = null;
try { // for error handling
{
stmt_list();
s_AST = (Aast)returnAST;
}
statement_AST = (Aast)currentAST.root;
if (s_AST == null)
{
// the empty statement can generate a null return AST
statement_AST = null;
}
else if (s_AST.getType() == EMBEDDED_SQL)
{
// don't root this at a STATEMENT node
statement_AST = s_AST;
}
else
{
// otherwise root everything at an artificial node
statement_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(STATEMENT,"statement")).add(s_AST));
}
currentAST.root = statement_AST;
currentAST.child = statement_AST!=null &&statement_AST.getFirstChild()!=null ?
statement_AST.getFirstChild() : statement_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = statement_AST;
}
/**
* Undocumented syntax found in working code that appears to be ignored in Progress. Match the
* text and anything else until a final DOT is reached.
* <p>
* All legacy annotations are emitted as ANNOTATION ASTs - the conversion rules will decide to
* keep them (if they are associated with a service, for example) or to discard them.
*/
public final void oea_annotations() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast oea_annotations_AST = null;
try { // for error handling
oea_annotation();
astFactory.addASTChild(currentAST, returnAST);
match(DOT);
oea_annotations_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = oea_annotations_AST;
}
/**
* Matches the syntax of a legacy annotation. An enhancement is supported, where an attribute can
* have an array initializer (via the 4GL-style brackets), with other annotations as values.
*/
public final void oea_annotation() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast oea_annotation_AST = null;
Token a = null;
Aast a_AST = null;
Aast s_AST = null;
try { // for error handling
a = LT(1);
a_AST = (Aast)astFactory.create(a);
astFactory.makeASTRoot(currentAST, a_AST);
match(AT);
any_symbol_at_all();
astFactory.addASTChild(currentAST, returnAST);
saveAndReplaceType(a_AST, ANNOTATION);
{
if ((_tokenSet_1.member(LA(1)))) {
any_symbol_at_all();
s_AST = (Aast)returnAST;
hide(s_AST);
}
else if ((_tokenSet_25.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case LPARENS:
{
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_1.member(LA(1)))) {
oea_annotation_arg();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==COMMA||LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop28:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
oea_annotation_arg();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop28;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case RBRACKET:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
oea_annotation_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_26);
}
returnAST = oea_annotation_AST;
}
/**
* Matches a {@link #reserved_or_symbol}, a <code>DB_SYMBOL</code>,
* <code>BOOL_TRUE</code>, <code>BOOL_FALSE</code> or a<code>FILENAME</code>
* and always returns a <code>SYMBOL</code> node.
*/
public final void any_symbol_at_all() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast any_symbol_at_all_AST = null;
Token y = null;
Aast y_AST = null;
Token n = null;
Aast n_AST = null;
Token d = null;
Aast d_AST = null;
Token f = null;
Aast f_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case BOOL_TRUE:
{
y = LT(1);
y_AST = (Aast)astFactory.create(y);
astFactory.addASTChild(currentAST, y_AST);
match(BOOL_TRUE);
y_AST.setType(SYMBOL);
break;
}
case BOOL_FALSE:
{
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.addASTChild(currentAST, n_AST);
match(BOOL_FALSE);
n_AST.setType(SYMBOL);
break;
}
case DB_SYMBOL:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.addASTChild(currentAST, d_AST);
match(DB_SYMBOL);
d_AST.setType(SYMBOL);
break;
}
case FILENAME:
{
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.addASTChild(currentAST, f_AST);
match(FILENAME);
f_AST.setType(SYMBOL);
break;
}
default:
if ((_tokenSet_27.member(LA(1)))) {
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
any_symbol_at_all_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = any_symbol_at_all_AST;
}
/**
* Matches the <code>LPARENS</code> token. This drops the node from the tree while
* patching the token into the hidden token stream.
*/
public final void lparens() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast lparens_AST = null;
Token l = null;
Aast l_AST = null;
try { // for error handling
l = LT(1);
l_AST = (Aast)astFactory.create(l);
match(LPARENS);
hide(l);
lparens_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_28);
}
returnAST = lparens_AST;
}
/**
* Matches an annotation argument, via a 'attribute=val' pair or 'attribute=[@Anno1, @Anno2, ..]'.
*/
public final void oea_annotation_arg() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast oea_annotation_arg_AST = null;
Token eq = null;
Aast eq_AST = null;
try { // for error handling
any_symbol_at_all();
astFactory.addASTChild(currentAST, returnAST);
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(EQUALS);
{
switch ( LA(1)) {
case BOOL_TRUE:
case BOOL_FALSE:
case DEC_LITERAL:
case DATE_LITERAL:
case DATETIME_LITERAL:
case DATETIME_TZ_LITERAL:
case HEX_LITERAL:
case UNQUOTED_TEXT:
case KW_B_ENDIAN:
case KW_DLL_C_T:
case KW_EXC_LOCK:
case KW_FIND_CS:
case KW_FIND_GLO:
case KW_FIND_NO:
case KW_FIND_PO:
case KW_FIND_SEL:
case KW_FIND_WA:
case KW_FUNC_C_T:
case KW_GET_A_CT:
case KW_HOST_B_O:
case KW_L_ENDIAN:
case KW_NO_LOCK:
case KW_NO_WAIT:
case KW_PROC_C_T:
case KW_READ_AVL:
case KW_READ_E_N:
case KW_ROW_CRTD:
case KW_ROW_DELD:
case KW_ROW_MODD:
case KW_ROW_UMOD:
case KW_SAX_COMP:
case KW_SAX_PARE:
case KW_SAX_RUNN:
case KW_SAX_UNIN:
case KW_SAX_WBEG:
case KW_SAX_WCOM:
case KW_SAX_WCON:
case KW_SAX_WELM:
case KW_SAX_WERR:
case KW_SAX_WIDL:
case KW_SAX_WTAG:
case KW_SEAR_SLF:
case KW_SEAR_TRG:
case KW_SET_A_CT:
case KW_SH_LOCK:
case KW_WIN_DMIN:
case KW_WIN_MAX:
case KW_WIN_MIN:
case KW_WIN_NORM:
case STRING:
case UNKNOWN_VAL:
case NUM_LITERAL:
{
literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LBRACKET:
{
oea_annotation_array();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
saveAndReplaceType(eq_AST, ASSIGN);
oea_annotation_arg_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_29);
}
returnAST = oea_annotation_arg_AST;
}
/**
* Matches <code>COMMA</code> token. This drops the node from the tree while
* patching the token into the hidden token stream.
*/
public final void comma() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast comma_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
match(COMMA);
hide(c);
comma_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_28);
}
returnAST = comma_AST;
}
/**
* Matches the <code>RPARENS</code> token. This drops the node from the tree while
* patching the token into the hidden token stream.
*/
public final void rparens() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast rparens_AST = null;
Token r = null;
Aast r_AST = null;
try { // for error handling
r = LT(1);
r_AST = (Aast)astFactory.create(r);
match(RPARENS);
hide(r);
rparens_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = rparens_AST;
}
/**
* Matches all variations of Progress literals (constants). This includes:
* <pre>
* NUM_LITERAL
* HEX_LITERAL
* DEC_LITERAL
* STRING
* BOOL_TRUE
* BOOL_FALSE
* DATE_LITERAL
* DATETIME_LITERAL
* DATETIME_TZ_LITERAL
* UNKNOWN_VAL
* KW_FIND_NO (compiler constant == 1)
* KW_FIND_PO (compiler constant == 2)
* KW_FIND_CS (compiler constant == 4)
* KW_FIND_GLO (compiler constant == 8)
* KW_FIND_WA (compiler constant == 16)
* KW_FIND_SEL (compiler constant == 32)
* KW_READ_AVL (compiler constant == 1)
* KW_READ_E_N (compiler constant == 2)
* KW_ROW_UMOD (ROW-STATE value, compiler constant == 0)
* KW_ROW_DELD (ROW-STATE value, compiler constant == 1)
* KW_ROW_MODD (ROW-STATE value, compiler constant == 2)
* KW_ROW_CRTD (ROW-STATE value, compiler constant == 3)
* KW_SAX_COMP (compiler constant == 3)
* KW_SAX_PARE (compiler constant == 4)
* KW_SAX_RUNN (compiler constant == 2)
* KW_SAX_UNIN (compiler constant == 1)
* KW_SAX_WBEG (compiler constant == 2)
* KW_SAX_WCOM (compiler constant == 6)
* KW_SAX_WCON (compiler constant == 5)
* KW_SAX_WELM (compiler constant == 4)
* KW_SAX_WERR (compiler constant == 7)
* KW_SAX_WIDL (compiler constant == 1)
* KW_SAX_WTAG (compiler constant == 3)
* KW_WIN_DMIN (undocumented keyword which is a compiler constant == 4)
* KW_WIN_MAX (compiler constant == 1)
* KW_WIN_MIN (compiler constant == 2)
* KW_WIN_NORM (compiler constant == 3)
* KW_SEAR_SLF (SEARCH-SELF mode for the add-super-procedure() parameter, compiler constant == 1)
* KW_SEAR_TRG (SEARCH-TARGET mode for the add-super-procedure() parameter, compiler constant == 2)
* KW_HOST_B_O (compiler constant == 1)
* KW_B_ENDIAN (compiler constant == 2)
* KW_L_ENDIAN (compiler constant == 3)
* </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>
* Certain upstream usage of expressions (see {@link #form_item}) enable a
* special mode of parsing where 2 or more unquoted '-' or '+' characters
* are matched as a string literal. Note that the characters cannot be
* intermixed without intervening whitespace and no other non-alphanumeric
* characters on the U.S. keyboard have this same behavior.
*/
public final void literal() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast literal_AST = null;
Token n = null;
Aast n_AST = null;
Token h = null;
Aast h_AST = null;
Token nl = null;
Aast nl_AST = null;
Token sl = null;
Aast sl_AST = null;
Token el = null;
Aast el_AST = null;
Token nw = null;
Aast nw_AST = null;
Token ra = null;
Aast ra_AST = null;
Token re = null;
Aast re_AST = null;
Token t1 = null;
Aast t1_AST = null;
Token t2 = null;
Aast t2_AST = null;
Token t3 = null;
Aast t3_AST = null;
Token t4 = null;
Aast t4_AST = null;
Token t5 = null;
Aast t5_AST = null;
Token ss = null;
Aast ss_AST = null;
Token st = null;
Aast st_AST = null;
Token ut = null;
Aast ut_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case NUM_LITERAL:
{
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.addASTChild(currentAST, n_AST);
match(NUM_LITERAL);
sym.annotateNumericLiteral(n_AST);
break;
}
case DEC_LITERAL:
{
Aast tmp40_AST = null;
tmp40_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp40_AST);
match(DEC_LITERAL);
break;
}
case HEX_LITERAL:
{
h = LT(1);
h_AST = (Aast)astFactory.create(h);
astFactory.addASTChild(currentAST, h_AST);
match(HEX_LITERAL);
sym.annotateNumericLiteral(h_AST);
break;
}
case STRING:
{
Aast tmp41_AST = null;
tmp41_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp41_AST);
match(STRING);
break;
}
case BOOL_TRUE:
{
Aast tmp42_AST = null;
tmp42_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp42_AST);
match(BOOL_TRUE);
break;
}
case BOOL_FALSE:
{
Aast tmp43_AST = null;
tmp43_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp43_AST);
match(BOOL_FALSE);
break;
}
case DATE_LITERAL:
{
Aast tmp44_AST = null;
tmp44_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp44_AST);
match(DATE_LITERAL);
break;
}
case DATETIME_LITERAL:
{
Aast tmp45_AST = null;
tmp45_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp45_AST);
match(DATETIME_LITERAL);
break;
}
case DATETIME_TZ_LITERAL:
{
Aast tmp46_AST = null;
tmp46_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp46_AST);
match(DATETIME_TZ_LITERAL);
break;
}
case UNKNOWN_VAL:
{
Aast tmp47_AST = null;
tmp47_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp47_AST);
match(UNKNOWN_VAL);
break;
}
case KW_NO_LOCK:
{
nl = LT(1);
nl_AST = (Aast)astFactory.create(nl);
astFactory.addASTChild(currentAST, nl_AST);
match(KW_NO_LOCK);
nl_AST.setType(NO_LOCK_LITERAL);
break;
}
case KW_SH_LOCK:
{
sl = LT(1);
sl_AST = (Aast)astFactory.create(sl);
astFactory.addASTChild(currentAST, sl_AST);
match(KW_SH_LOCK);
sl_AST.setType(SHARE_LOCK_LITERAL);
break;
}
case KW_EXC_LOCK:
{
el = LT(1);
el_AST = (Aast)astFactory.create(el);
astFactory.addASTChild(currentAST, el_AST);
match(KW_EXC_LOCK);
el_AST.setType(EXCLUSIVE_LOCK_LITERAL);
break;
}
case KW_NO_WAIT:
{
nw = LT(1);
nw_AST = (Aast)astFactory.create(nw);
astFactory.addASTChild(currentAST, nw_AST);
match(KW_NO_WAIT);
nw_AST.setType(NO_WAIT_LITERAL);
break;
}
case KW_READ_AVL:
{
ra = LT(1);
ra_AST = (Aast)astFactory.create(ra);
astFactory.addASTChild(currentAST, ra_AST);
match(KW_READ_AVL);
ra_AST.setType(READ_AVAILABLE_LITERAL);
break;
}
case KW_READ_E_N:
{
re = LT(1);
re_AST = (Aast)astFactory.create(re);
astFactory.addASTChild(currentAST, re_AST);
match(KW_READ_E_N);
re_AST.setType(READ_EXACT_NUM_LITERAL);
break;
}
case KW_PROC_C_T:
{
t1 = LT(1);
t1_AST = (Aast)astFactory.create(t1);
astFactory.addASTChild(currentAST, t1_AST);
match(KW_PROC_C_T);
t1_AST.setType(PROC_CALL_TYPE_LITERAL);
break;
}
case KW_FUNC_C_T:
{
t2 = LT(1);
t2_AST = (Aast)astFactory.create(t2);
astFactory.addASTChild(currentAST, t2_AST);
match(KW_FUNC_C_T);
t2_AST.setType(FUNC_CALL_TYPE_LITERAL);
break;
}
case KW_GET_A_CT:
{
t3 = LT(1);
t3_AST = (Aast)astFactory.create(t3);
astFactory.addASTChild(currentAST, t3_AST);
match(KW_GET_A_CT);
t3_AST.setType(GET_ATTR_CTYPE_LITERAL);
break;
}
case KW_SET_A_CT:
{
t4 = LT(1);
t4_AST = (Aast)astFactory.create(t4);
astFactory.addASTChild(currentAST, t4_AST);
match(KW_SET_A_CT);
t4_AST.setType(SET_ATTR_CTYPE_LITERAL);
break;
}
case KW_DLL_C_T:
{
t5 = LT(1);
t5_AST = (Aast)astFactory.create(t5);
astFactory.addASTChild(currentAST, t5_AST);
match(KW_DLL_C_T);
t5_AST.setType(DLL_CALL_TYPE_LITERAL);
break;
}
case KW_FIND_NO:
{
Aast tmp48_AST = null;
tmp48_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp48_AST);
match(KW_FIND_NO);
break;
}
case KW_FIND_SEL:
{
Aast tmp49_AST = null;
tmp49_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp49_AST);
match(KW_FIND_SEL);
break;
}
case KW_FIND_PO:
{
Aast tmp50_AST = null;
tmp50_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp50_AST);
match(KW_FIND_PO);
break;
}
case KW_FIND_CS:
{
Aast tmp51_AST = null;
tmp51_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp51_AST);
match(KW_FIND_CS);
break;
}
case KW_FIND_GLO:
{
Aast tmp52_AST = null;
tmp52_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp52_AST);
match(KW_FIND_GLO);
break;
}
case KW_FIND_WA:
{
Aast tmp53_AST = null;
tmp53_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp53_AST);
match(KW_FIND_WA);
break;
}
case KW_ROW_UMOD:
{
Aast tmp54_AST = null;
tmp54_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp54_AST);
match(KW_ROW_UMOD);
break;
}
case KW_ROW_DELD:
{
Aast tmp55_AST = null;
tmp55_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp55_AST);
match(KW_ROW_DELD);
break;
}
case KW_ROW_MODD:
{
Aast tmp56_AST = null;
tmp56_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp56_AST);
match(KW_ROW_MODD);
break;
}
case KW_ROW_CRTD:
{
Aast tmp57_AST = null;
tmp57_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp57_AST);
match(KW_ROW_CRTD);
break;
}
case KW_SAX_COMP:
{
Aast tmp58_AST = null;
tmp58_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp58_AST);
match(KW_SAX_COMP);
break;
}
case KW_SAX_PARE:
{
Aast tmp59_AST = null;
tmp59_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp59_AST);
match(KW_SAX_PARE);
break;
}
case KW_SAX_RUNN:
{
Aast tmp60_AST = null;
tmp60_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp60_AST);
match(KW_SAX_RUNN);
break;
}
case KW_SAX_UNIN:
{
Aast tmp61_AST = null;
tmp61_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp61_AST);
match(KW_SAX_UNIN);
break;
}
case KW_SAX_WBEG:
{
Aast tmp62_AST = null;
tmp62_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp62_AST);
match(KW_SAX_WBEG);
break;
}
case KW_SAX_WCOM:
{
Aast tmp63_AST = null;
tmp63_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp63_AST);
match(KW_SAX_WCOM);
break;
}
case KW_SAX_WCON:
{
Aast tmp64_AST = null;
tmp64_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp64_AST);
match(KW_SAX_WCON);
break;
}
case KW_SAX_WELM:
{
Aast tmp65_AST = null;
tmp65_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp65_AST);
match(KW_SAX_WELM);
break;
}
case KW_SAX_WERR:
{
Aast tmp66_AST = null;
tmp66_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp66_AST);
match(KW_SAX_WERR);
break;
}
case KW_SAX_WIDL:
{
Aast tmp67_AST = null;
tmp67_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp67_AST);
match(KW_SAX_WIDL);
break;
}
case KW_SAX_WTAG:
{
Aast tmp68_AST = null;
tmp68_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp68_AST);
match(KW_SAX_WTAG);
break;
}
case KW_WIN_DMIN:
{
Aast tmp69_AST = null;
tmp69_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp69_AST);
match(KW_WIN_DMIN);
break;
}
case KW_WIN_MAX:
{
Aast tmp70_AST = null;
tmp70_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp70_AST);
match(KW_WIN_MAX);
break;
}
case KW_WIN_MIN:
{
Aast tmp71_AST = null;
tmp71_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp71_AST);
match(KW_WIN_MIN);
break;
}
case KW_WIN_NORM:
{
Aast tmp72_AST = null;
tmp72_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp72_AST);
match(KW_WIN_NORM);
break;
}
case KW_SEAR_SLF:
{
ss = LT(1);
ss_AST = (Aast)astFactory.create(ss);
astFactory.addASTChild(currentAST, ss_AST);
match(KW_SEAR_SLF);
ss_AST.setType(SEARCH_SELF_LITERAL);
break;
}
case KW_SEAR_TRG:
{
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(KW_SEAR_TRG);
st_AST.setType(SEARCH_TARGET_LITERAL);
break;
}
case KW_HOST_B_O:
{
Aast tmp73_AST = null;
tmp73_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp73_AST);
match(KW_HOST_B_O);
break;
}
case KW_B_ENDIAN:
{
Aast tmp74_AST = null;
tmp74_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp74_AST);
match(KW_B_ENDIAN);
break;
}
case KW_L_ENDIAN:
{
Aast tmp75_AST = null;
tmp75_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp75_AST);
match(KW_L_ENDIAN);
break;
}
default:
if (((LA(1)==UNQUOTED_TEXT))&&( allowStringMatch )) {
ut = LT(1);
ut_AST = (Aast)astFactory.create(ut);
astFactory.addASTChild(currentAST, ut_AST);
match(UNQUOTED_TEXT);
saveAndReplaceTypeAndText(ut_AST, STRING, "'" + ut_AST.getText() + "'");
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
literal_AST = (Aast)currentAST.root;
literal_AST.putAnnotation("is-literal", Boolean.valueOf(true));
literal_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = literal_AST;
}
/**
* Matches a 4GL-style array initializer with other legacy annotations definitions.
*/
public final void oea_annotation_array() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast oea_annotation_array_AST = null;
Token r = null;
Aast r_AST = null;
try { // for error handling
Aast tmp76_AST = null;
tmp76_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp76_AST);
match(LBRACKET);
{
switch ( LA(1)) {
case AT:
{
oea_annotation();
astFactory.addASTChild(currentAST, returnAST);
{
_loop34:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
oea_annotation();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop34;
}
} while (true);
}
break;
}
case RBRACKET:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
r = LT(1);
r_AST = (Aast)astFactory.create(r);
match(RBRACKET);
hide(r);
oea_annotation_array_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_29);
}
returnAST = oea_annotation_array_AST;
}
/**
* Matches the <code>DOT</code> statement terminator. This drops the node from the tree while
* patching the token into the hidden token stream.
*/
public final void stmt_term() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast stmt_term_AST = null;
Token d = null;
Aast d_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
match(DOT);
hide(d);
stmt_term_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = stmt_term_AST;
}
/**
* Matches the <code>DOT</code> or <code>COLON</code> block terminator. This drops the node from
* the tree while patching the token into the hidden token stream.
*/
public final void block_term() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast block_term_AST = null;
Token d = null;
Aast d_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case DOT:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
match(DOT);
break;
}
case COLON:
{
c = LT(1);
c_AST = (Aast)astFactory.create(c);
match(COLON);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
hide(d != null ? d : c);
block_term_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = block_term_AST;
}
/**
* Matches the <code>COLON</code> token. This drops the node from the tree while
* patching the token into the hidden token stream.
*/
public final void colon() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast colon_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
match(COLON);
hide(c);
colon_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = colon_AST;
}
/**
* Implements the structure of a <code>PROCEDURE</code> block definition
* which is the manner in which Progress implements a form of subroutine.
* <p>
* The most important feature of this rule is the direct usage of the
* {@link #malformed_symbol} rule to force the second token to a
* <code>SYMBOL</code> token type. This allows reserved keywords and names that
* start with numbers or other characters that usually cannot be used as the
* first character of a symbol. Additionally, a <code>DB_SYMBOL</code>
* or a <code>FILENAME</code> can be matched there. This token is then used
* in the exit action to add the defined procedure's name to the procedure
* namespace.
* <p>
* Note that it is undocumented but possible to use reserved keywords as
* internal procedure names in Progress 4GL. Otherwise only the rule
* {@link #symbol} would have been needed.
* <p>
* Procedures do not have a return value. There is a special result code to
* optionally indicate success or failure but there is no way to call a
* procedure and assign the result to an lvalue. For this reason, there is
* no need to associate the procedure name with a special token type that
* is data type specific (i.e. this is different from functions and
* variables). A standard token type of <code>PROCEDURE</code> is associated
* with all procedures in the namespace, but it is not really used for
* anything.
*/
public final void proc_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast proc_stmt_AST = null;
Aast s_AST = null;
Aast external_AST = null;
try { // for error handling
boolean privateAccess = false;
CommonToken next = (CommonToken) LT(2);
String oldtxt = null;
int newlen = -1;
// TODO: this is the same logic as implemented in run_stmt, but proc_stmt is supposed to
// be more restrictive (see procedure_names_with_embedded_strings.p)
// the proc stmt can match a simple string but it can also match a string that prefixes
// other non-whitespace characters and it is the unquoted contents concatenated to the
// following text that is matched; to duplicate this we must get rid of the quotes here
// and duplicate any keyword processing that would otherwise have occurred; then we let
// the normal matching occur below; malformed_symbol() uses mergeUntilWS() to handle
// the token merging
if (next.getType() == STRING)
{
oldtxt = next.getText();
// convert the Progress string to a Java string (includes escape processing and
// removal of quotes)
String txt = character.progressToJavaString(oldtxt, !unixEscapes, true);
newlen = txt.length();
// no-transform approach to simply remove quotes; it is not clear if the above
// transformations should or should not be applied
// txt = txt.substring(1, txt.length() - 1);
// save cleaned up string
next.setText(txt);
// this next part is done in run_stmt but I don't think we need it here
// simulate the keyword processing that would have happened if this wasn't a string
// Keyword found = sym.lookupKeyword(txt);
// next.setType((found != null) ? found.getTokenType() : SYMBOL);
next.setType(SYMBOL);
}
{
Aast tmp77_AST = null;
tmp77_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp77_AST);
match(KW_PROC);
malformed_symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_EXTERN:
{
external_api_definition();
external_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_PRIVATE:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_PRIVATE:
{
Aast tmp78_AST = null;
tmp78_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp78_AST);
match(KW_PRIVATE);
privateAccess = true;
break;
}
case DOT:
case KW_IN:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_IN:
{
in_super_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
block_term();
astFactory.addASTChild(currentAST, returnAST);
if (!( nestLevel < 2 || (insideClass && nestLevel == 2 && external_AST != null)))
throw new SemanticException(" nestLevel < 2 || (insideClass && nestLevel == 2 && external_AST != null)");
}
proc_stmt_AST = (Aast)currentAST.root;
String stxt = s_AST.getText();
// original token (or the first token of a merged set) was STRING but was rewritten
// above; we need to calculate the actual full original text and save it for
// possible anti-parsing later
if (oldtxt != null)
{
String backend = stxt.substring(newlen);
s_AST.putAnnotation("original-text", oldtxt + backend);
}
sym.addProcedure(stxt, INT_PROC);
// remember if the method should be private
if (privateAccess)
{
proc_stmt_AST.putAnnotation("access", "private");
}
proc_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = proc_stmt_AST;
}
/**
* Matches an <code>END</code> Progress 4GL language statement. This is the
* rule that ends all Progress block definitions.
* <p>
* Note that Progress 4GL allows an optional keyword to be placed between the
* <code>KW_END</code> and the <code>DOT</code> for some blocks. This works
* for <code>CASE</code>, <code>PROCEDURE</code>, <code>FUNCTION</code> and
* <code>TRIGGERS</code> keywords. It does not work for <code>DO</code>,
* <code>REPEAT</code> or <code>FOR</code> keywords. This feature is
* completely implemented except in Progress 4GL, abbreviations cannot be
* used in this optional keyword, but in this implementation abbreviations
* are tolerated. Since they should not be encountered in practice, this is
* an acceptable decision.
* <p>
* <b>DO NOT EVER include this directly in the {@link #stmt_list} rule
* otherwise all block processing will break!</b>
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*
* @param eat
* Match (and drop) a following <code>DOT</code> if one exists.
*/
public final void end_stmt(
boolean eat
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast end_stmt_AST = null;
Token en = null;
Aast en_AST = null;
Token ca = null;
Aast ca_AST = null;
Token ct = null;
Aast ct_AST = null;
Token cl = null;
Aast cl_AST = null;
Token co = null;
Aast co_AST = null;
Token de = null;
Aast de_AST = null;
Token em = null;
Aast em_AST = null;
Token fi = null;
Aast fi_AST = null;
Token fu = null;
Aast fu_AST = null;
Token ge = null;
Aast ge_AST = null;
Token in = null;
Aast in_AST = null;
Token me = null;
Aast me_AST = null;
Token pr = null;
Aast pr_AST = null;
Token se = null;
Aast se_AST = null;
Token tr = null;
Aast tr_AST = null;
try { // for error handling
en = LT(1);
en_AST = (Aast)astFactory.create(en);
match(KW_END);
hide(en);
{
if ((LA(1)==KW_CASE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ca = LT(1);
ca_AST = (Aast)astFactory.create(ca);
match(KW_CASE);
hide(ca);
}
else if ((LA(1)==KW_CATCH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ct = LT(1);
ct_AST = (Aast)astFactory.create(ct);
match(KW_CATCH);
hide(ct);
}
else if ((LA(1)==KW_CLASS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLASS);
hide(cl);
}
else if ((LA(1)==KW_CONSTRUC) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
co = LT(1);
co_AST = (Aast)astFactory.create(co);
match(KW_CONSTRUC);
hide(co);
}
else if ((LA(1)==KW_DESTRUCT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
de = LT(1);
de_AST = (Aast)astFactory.create(de);
match(KW_DESTRUCT);
hide(de);
}
else if ((LA(1)==KW_ENUM) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
em = LT(1);
em_AST = (Aast)astFactory.create(em);
match(KW_ENUM);
hide(em);
}
else if ((LA(1)==KW_FINALLY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
fi = LT(1);
fi_AST = (Aast)astFactory.create(fi);
match(KW_FINALLY);
hide(fi);
}
else if ((LA(1)==KW_FUNCT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
fu = LT(1);
fu_AST = (Aast)astFactory.create(fu);
match(KW_FUNCT);
hide(fu);
}
else if ((LA(1)==KW_GET) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ge = LT(1);
ge_AST = (Aast)astFactory.create(ge);
match(KW_GET);
hide(ge);
}
else if ((LA(1)==KW_INTERFAC) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INTERFAC);
hide(in);
}
else if ((LA(1)==KW_METHOD) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
me = LT(1);
me_AST = (Aast)astFactory.create(me);
match(KW_METHOD);
hide(me);
}
else if ((LA(1)==KW_PROC) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PROC);
hide(pr);
}
else if ((LA(1)==KW_SET) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
se = LT(1);
se_AST = (Aast)astFactory.create(se);
match(KW_SET);
hide(se);
}
else if ((LA(1)==KW_TRIGGERS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tr = LT(1);
tr_AST = (Aast)astFactory.create(tr);
match(KW_TRIGGERS);
hide(tr);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==DOT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( eat )) {
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
end_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = end_stmt_AST;
}
/**
* Matches a name which can be a simple symbol or optionally can be any number of tokens until
* it finds whitespace, COLON, DOT, EQUALS, RPARENS, LPARENS, NOT_EQ, LT, LTE, GT or GTE.
* <p>
* Certain resource names are unusual symbols in that they can begin with a numeric digit,
* minus sign and other unexpected characters that normally can only occur as the 2nd or
* later character in a symbol. In addition, other non-symbol tokens can appear inside
* such symbols (e.g. the @ sign). All of this is based on real cases found in customer
* source code.
* <p>
* This special case is converted into a single <code>SYMBOL</code> token with the concatenated
* text of all merged tokens.
* <p>
* Resource types that have this undocumented behavior:
* <p>
* <ol>
* <li> frame names
* <li> labels
* <li> query names
* <li> stream names
* <li> procedure names
* <li> function names
* <li> radio-button names
* <li> db_ref-non_static names
* </ol>
*/
public final void malformed_symbol() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast malformed_symbol_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
// DOT and EOF are hard coded in the worker routine
// TODO: UNKNOWN_TOKEN should have broken out RBRACE and PIPE
// so they can be matched individually
int[] exclude = new int[]
{
COLON,
DB_REF_NON_STATIC,
LPARENS,
RPARENS,
LBRACKET,
RBRACKET,
COMMA,
EQUALS,
NOT_EQ,
LT,
GT,
LTE,
GTE
};
boolean bad = mergeUntilWS(exclude);
LT(1).setType(SYMBOL);
{
if ((LA(1)==SYMBOL)) {
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.makeASTRoot(currentAST, s_AST);
match(SYMBOL);
}
else if ((_tokenSet_30.member(LA(1)))) {
Aast tmp79_AST = null;
tmp79_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp79_AST);
matchNot(DOT);
Aast tmp80_AST = null;
tmp80_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp80_AST);
matchNot(DOT);
Aast tmp81_AST = null;
tmp81_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp81_AST);
matchNot(DOT);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
malformed_symbol_AST = (Aast)currentAST.root;
if (bad)
{
malformed_symbol_AST.putAnnotation("malformed", Boolean.valueOf(true));
}
malformed_symbol_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = malformed_symbol_AST;
}
/**
* Match the <code>EXTERNAL</code> keyword with a required following
* <code>STRING</code> (shared library name). Uses {@link #ordinal_clause}.
* Used by {@link #proc_stmt}.
*/
public final void external_api_definition() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast external_api_definition_AST = null;
try { // for error handling
Aast tmp82_AST = null;
tmp82_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp82_AST);
match(KW_EXTERN);
Aast tmp83_AST = null;
tmp83_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp83_AST);
match(STRING);
{
_loop55:
do {
switch ( LA(1)) {
case KW_CDECL:
{
Aast tmp84_AST = null;
tmp84_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp84_AST);
match(KW_CDECL);
break;
}
case KW_PASCAL:
{
Aast tmp85_AST = null;
tmp85_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp85_AST);
match(KW_PASCAL);
break;
}
case KW_STDCALL:
{
Aast tmp86_AST = null;
tmp86_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp86_AST);
match(KW_STDCALL);
break;
}
case KW_ORDINAL:
{
ordinal_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PERSIST:
{
Aast tmp87_AST = null;
tmp87_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp87_AST);
match(KW_PERSIST);
break;
}
default:
{
break _loop55;
}
}
} while (true);
}
external_api_definition_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_31);
}
returnAST = external_api_definition_AST;
}
/**
* Matches <code>IN SUPER</code> keywords in a {@link #func_stmt} and is
* separated to improve the tree.
*/
public final void in_super_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_super_clause_AST = null;
try { // for error handling
Aast tmp88_AST = null;
tmp88_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp88_AST);
match(KW_IN);
Aast tmp89_AST = null;
tmp89_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp89_AST);
match(KW_SUPER);
in_super_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = in_super_clause_AST;
}
/**
* Match the <code>ORDINAL</code> keyword with a required following
* <code>whole_number_literal</code>. Used by {@link #external_api_definition}.
*/
public final void ordinal_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast ordinal_clause_AST = null;
try { // for error handling
Aast tmp90_AST = null;
tmp90_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp90_AST);
match(KW_ORDINAL);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
ordinal_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_33);
}
returnAST = ordinal_clause_AST;
}
/**
* Matches any whole number literal (<code>NUM_LITERAL</code> or a <code>HEX_LITERAL</code>).
*/
public final void whole_number_literal() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast whole_number_literal_AST = null;
Token n = null;
Aast n_AST = null;
Token h = null;
Aast h_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case NUM_LITERAL:
{
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.addASTChild(currentAST, n_AST);
match(NUM_LITERAL);
sym.annotateNumericLiteral(n_AST);
break;
}
case HEX_LITERAL:
{
h = LT(1);
h_AST = (Aast)astFactory.create(h);
astFactory.addASTChild(currentAST, h_AST);
match(HEX_LITERAL);
sym.annotateNumericLiteral(h_AST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
whole_number_literal_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = whole_number_literal_AST;
}
/**
* Matches the <code>KW_INHERITS</code> with a following
* {@link #user_defined_type_name}. This defines the superclass for a
* {@link #class_stmt}.
*/
public final void inherits_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast inherits_clause_AST = null;
try { // for error handling
Aast tmp91_AST = null;
tmp91_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp91_AST);
match(KW_INHERITS);
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
inherits_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_34);
}
returnAST = inherits_clause_AST;
}
/**
* Matches <code>KW_IMPLMTS</code> with one or more comma-separated following
* {@link #user_defined_type_name}. Used by {@link #class_stmt}.
*/
public final void implements_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast implements_clause_AST = null;
try { // for error handling
Aast tmp92_AST = null;
tmp92_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp92_AST);
match(KW_IMPLEMTS);
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
{
_loop73:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop73;
}
} while (true);
}
implements_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_34);
}
returnAST = implements_clause_AST;
}
/**
* Matches an {@link #any_symbol_at_all} or a <code>STRING</code> and if it
* represents an unqualified class name, it will be resolved into the fully
* qualified class name that is referenced. The resulting qualified name will
* be stored in an annotation named "qualified". The resulting node type will
* always be <code>CLASS_NAME</code>.
* <p>
* The 10.2x syntax which allows a main.class.Name+InnerClassName format is
* supported here.
*/
public final void user_defined_type_name() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast user_defined_type_name_AST = null;
Aast sym_AST = null;
Token pl = null;
Aast pl_AST = null;
Aast innerCls_AST = null;
Token str = null;
Aast str_AST = null;
try { // for error handling
{
if ((_tokenSet_1.member(LA(1)))) {
any_symbol_at_all();
sym_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==PLUS) && (_tokenSet_1.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
pl = LT(1);
pl_AST = (Aast)astFactory.create(pl);
match(PLUS);
hide(pl);
any_symbol_at_all();
innerCls_AST = (Aast)returnAST;
hide(innerCls_AST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((LA(1)==STRING)) {
str = LT(1);
str_AST = (Aast)astFactory.create(str);
astFactory.addASTChild(currentAST, str_AST);
match(STRING);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
user_defined_type_name_AST = (Aast)currentAST.root;
String name = null;
if (sym_AST != null)
{
name = sym_AST.getText();
if (innerCls_AST != null)
{
name = name + "+" + innerCls_AST.getText();
// we don't have to use #sym.setText(name) here because the nodes above were
// hidden and so they can be anti-parsed naturally
}
}
else
{
name = character.progressToJavaString(str_AST.getText(), !unixEscapes, false);
// if this is a reference to a .NET class, the 4GL allows the string literal form to contain
// a generics syntax in the form "dotnot_class_or_iface<other_dotnet_class_or_iface>"; the
// non-string form (above) can't have this syntax; 4GL class names can't use this either;
// we must strip the generics portion before we try to lookup the main class
int idx = name.indexOf('<');
if (idx != -1)
{
String typeParm = name.substring(idx + 1, name.length() - 1);
Keyword found = sym.lookupKeyword(typeParm);
String qualTypeParm = typeParm;
if (found != null && isPrimitiveType(found.getTokenType()))
{
str_AST.putAnnotation("generic-type-is-primitive", true);
}
else
{
qualTypeParm = sym.loadClass(typeParm);
if (qualTypeParm == null)
{
String err = String.format("Unresolvable generic type parameter '%s'.", typeParm);
throw genExc(err, user_defined_type_name_AST);
}
}
str_AST.putAnnotation("generic-type-parameter", qualTypeParm);
name = name.substring(0, idx);
}
saveAndReplaceText(str_AST, name);
}
String full = sym.loadClass(name);
if (full == null)
{
String err = String.format("Unresolvable user defined type '%s'.", name);
throw genExc(err, user_defined_type_name_AST);
}
sym.annotateClassRef(full, user_defined_type_name_AST);
saveAndReplaceType(user_defined_type_name_AST, CLASS_NAME);
user_defined_type_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = user_defined_type_name_AST;
}
/**
* Matches the <code>KW_INHERITS</code> with a following comma-separated list of
* {@link #user_defined_type_name}. This defines the list of super-interfaces for an
* {@link #interface_stmt}.
*/
public final void multiple_inherits_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast multiple_inherits_clause_AST = null;
try { // for error handling
Aast tmp93_AST = null;
tmp93_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp93_AST);
match(KW_INHERITS);
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
{
_loop70:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop70;
}
} while (true);
}
multiple_inherits_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = multiple_inherits_clause_AST;
}
/**
* Matches one or more {@link #def_enum_stmt} references.
*/
public final void enum_stmt_body() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast enum_stmt_body_AST = null;
try { // for error handling
{
int _cnt92=0;
_loop92:
do {
if ((LA(1)==KW_DEFINE) && (LA(2)==KW_ENUM) && (_tokenSet_1.member(LA(3)))) {
def_enum_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt92>=1 ) { break _loop92; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt92++;
} while (true);
}
enum_stmt_body_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = enum_stmt_body_AST;
}
/**
* Matches an enum member name (as {@link #any_symbol_at_all}) and optionally an {@code EQUALS}
* and one member name, a comma-separated list of member names or a {@link #whole_number_literal}
* reference. If the {@code EQUALS} is present, it will be the root node. The actual enum's
* symbol will be of type {@code ENUM_VALUE}.
*/
public final void enum_member() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast enum_member_AST = null;
Aast e_AST = null;
try { // for error handling
any_symbol_at_all();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
saveAndReplaceType(e_AST, ENUM_VALUE);
sym.addEnumMember(e_AST);
{
if ((LA(1)==EQUALS)) {
Aast tmp94_AST = null;
tmp94_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp94_AST);
match(EQUALS);
{
if ((_tokenSet_1.member(LA(1)))) {
{
any_symbol_at_all();
astFactory.addASTChild(currentAST, returnAST);
{
_loop101:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
any_symbol_at_all();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop101;
}
} while (true);
}
}
}
else if ((LA(1)==HEX_LITERAL||LA(1)==NUM_LITERAL)) {
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((_tokenSet_35.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
enum_member_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_35);
}
returnAST = enum_member_AST;
}
/**
* Matches an {@link #any_non_reserved_symbol} as a class name reference. This
* is the same idea as {@link #user_defined_type_name} except that here we do
* not match reserved keywords. This is required to provide the behavior of
* how class names are matched in {@link #primary_expr}. If the name is
* an unqualified class name, it will be resolved into the fully
* qualified class name that is referenced. The resulting qualified name will
* be stored in an annotation named "qualified". The resulting node type will
* always be <code>CLASS_NAME</code>.
*/
public final void non_reserved_user_defined_type_name() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast non_reserved_user_defined_type_name_AST = null;
Aast nam_AST = null;
Token pl = null;
Aast pl_AST = null;
Aast innerCls_AST = null;
try { // for error handling
any_non_reserved_symbol();
nam_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case PLUS:
{
pl = LT(1);
pl_AST = (Aast)astFactory.create(pl);
match(PLUS);
hide(pl);
any_symbol_at_all();
innerCls_AST = (Aast)returnAST;
hide(innerCls_AST);
break;
}
case EOF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
non_reserved_user_defined_type_name_AST = (Aast)currentAST.root;
String name = nam_AST.getText();
if (innerCls_AST != null)
{
name = name + "+" + innerCls_AST.getText();
// we don't have to use #nam.setText(name) here because the nodes above were
// hidden and so they can be anti-parsed naturally
}
String full = sym.loadClass(name);
if (full == null)
{
String err = String.format("Unresolvable user defined type '%s'.", name);
throw genExc(err, nam_AST);
}
sym.annotateClassRef(full, non_reserved_user_defined_type_name_AST);
non_reserved_user_defined_type_name_AST.setType(CLASS_NAME);
non_reserved_user_defined_type_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = non_reserved_user_defined_type_name_AST;
}
/**
* Matches a {@link #symbol}, a <code>DB_SYMBOL</code> or a
* <code>FILENAME</code> and always returns a <code>SYMBOL</code> node.
*/
public final void any_non_reserved_symbol() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast any_non_reserved_symbol_AST = null;
Token d = null;
Aast d_AST = null;
Token f = null;
Aast f_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case DB_SYMBOL:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.addASTChild(currentAST, d_AST);
match(DB_SYMBOL);
d_AST.setType(SYMBOL);
break;
}
case FILENAME:
{
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.addASTChild(currentAST, f_AST);
match(FILENAME);
f_AST.setType(SYMBOL);
break;
}
default:
if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
any_non_reserved_symbol_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = any_non_reserved_symbol_AST;
}
/**
* Matches the {@code KW_FROM} in a {@link #using_stmt}. There is a required following
* {@code KW_ASSEMBLY}, {@code KW_PROPATH} or {@code KW_JAVA} (this one is a FWD extension and
* is not a real 4GL feature).
* <p>
* Separated in order to build the tree properly.
*/
public final void from_assembly() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast from_assembly_AST = null;
try { // for error handling
Aast tmp95_AST = null;
tmp95_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp95_AST);
match(KW_FROM);
{
switch ( LA(1)) {
case KW_ASSEMBLY:
{
Aast tmp96_AST = null;
tmp96_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp96_AST);
match(KW_ASSEMBLY);
break;
}
case KW_PROPATH:
{
Aast tmp97_AST = null;
tmp97_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp97_AST);
match(KW_PROPATH);
break;
}
case KW_JAVA:
{
Aast tmp98_AST = null;
tmp98_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp98_AST);
match(KW_JAVA);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
from_assembly_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = from_assembly_AST;
}
/**
* Matches <code>KW_PUBLIC</code>, <code>KW_PROTECTD</code>,
* <code>KW_PRIVATE</code>, <code>KW_PK_PROT</code> or <code>KW_PK_PRIV</code>.
*/
public final void access_mode() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast access_mode_AST = null;
try { // for error handling
switch ( LA(1)) {
case KW_PUBLIC:
{
Aast tmp99_AST = null;
tmp99_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp99_AST);
match(KW_PUBLIC);
access_mode_AST = (Aast)currentAST.root;
break;
}
case KW_PROTECTD:
{
Aast tmp100_AST = null;
tmp100_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp100_AST);
match(KW_PROTECTD);
access_mode_AST = (Aast)currentAST.root;
break;
}
case KW_PRIVATE:
{
Aast tmp101_AST = null;
tmp101_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp101_AST);
match(KW_PRIVATE);
access_mode_AST = (Aast)currentAST.root;
break;
}
case KW_PK_PROT:
{
Aast tmp102_AST = null;
tmp102_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp102_AST);
match(KW_PK_PROT);
access_mode_AST = (Aast)currentAST.root;
break;
}
case KW_PK_PRIV:
{
Aast tmp103_AST = null;
tmp103_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp103_AST);
match(KW_PK_PRIV);
access_mode_AST = (Aast)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_0);
}
returnAST = access_mode_AST;
}
/**
* Matches a parenthesized list of comma-separated parameter definitions and uses a rule
* reference to {@link #parameter_spec} to properly build the AST. Note that the parameters
* are optional as some customer code has been found (in function definitions) that has an
* empty set of parenthesis.
* <p>
* Called from {@link #constructor_stmt}, {@link #method_stmt}, {@link #func_stmt},
* {@link #getter_setter} and {@link #event_signature}.
*
* @param defineBuffer
* <code>true</code> if the caller supports inline buffer
* definitions (versus just passing a buffer parameter which
* doesn't create a new buffer).
* @param funcDef
* <code>true</code> if the caller is a FUNCTION definition.
* @param oo
* {@code true} if being called from OO features. In OO usage, reserved keywords can
* be used as parameter names.
*/
public final void param_list_definition(
boolean defineBuffer, boolean funcDef, boolean oo
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast param_list_definition_AST = null;
try { // for error handling
Aast tmp104_AST = null;
tmp104_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp104_AST);
match(LPARENS);
{
if ((_tokenSet_0.member(LA(1)))) {
parameter_spec(defineBuffer, funcDef, oo);
astFactory.addASTChild(currentAST, returnAST);
{
_loop1605:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
parameter_spec(defineBuffer, funcDef, oo);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1605;
}
} while (true);
}
}
else if ((LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
param_list_definition_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = param_list_definition_AST;
}
/**
* Matches the return datatype of a user-defined method. This is used by
* {@link #method_stmt} and is only separated to make the AST build
* correctly.
*
* @return The token type of the method's return value.
*/
public final int method_return() throws RecognitionException, TokenStreamException {
int mtype = -1;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast method_return_AST = null;
Token k = null;
Aast k_AST = null;
Token cl = null;
Aast cl_AST = null;
try { // for error handling
{
if ((LA(1)==KW_VOID) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp105_AST = null;
tmp105_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp105_AST);
match(KW_VOID);
mtype = OO_METH_VOID;
}
else if ((LA(1)==KW_CHAR) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp106_AST = null;
tmp106_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp106_AST);
match(KW_CHAR);
mtype = OO_METH_CHAR;
}
else if ((LA(1)==KW_COM_HNDL) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp107_AST = null;
tmp107_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp107_AST);
match(KW_COM_HNDL);
mtype = OO_METH_COM_HANDLE;
}
else if ((LA(1)==KW_DATE) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp108_AST = null;
tmp108_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp108_AST);
match(KW_DATE);
mtype = OO_METH_DATE;
}
else if ((LA(1)==KW_DATETIME) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp109_AST = null;
tmp109_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp109_AST);
match(KW_DATETIME);
mtype = OO_METH_DATETIME;
}
else if ((LA(1)==KW_DATE_TZ) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp110_AST = null;
tmp110_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp110_AST);
match(KW_DATE_TZ);
mtype = OO_METH_DATETIME_TZ;
}
else if ((LA(1)==KW_DEC) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp111_AST = null;
tmp111_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp111_AST);
match(KW_DEC);
mtype = OO_METH_DEC;
}
else if ((LA(1)==KW_HANDLE) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp112_AST = null;
tmp112_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp112_AST);
match(KW_HANDLE);
mtype = OO_METH_HANDLE;
}
else if ((LA(1)==KW_WID_HAND) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp113_AST = null;
tmp113_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp113_AST);
match(KW_WID_HAND);
mtype = OO_METH_HANDLE;
}
else if ((LA(1)==KW_INT) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp114_AST = null;
tmp114_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp114_AST);
match(KW_INT);
mtype = OO_METH_INT;
}
else if ((LA(1)==KW_INT64) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp115_AST = null;
tmp115_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp115_AST);
match(KW_INT64);
mtype = OO_METH_INT64;
}
else if ((LA(1)==KW_LOG||LA(1)==KW_LOGICAL) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_LOGICAL:
{
Aast tmp116_AST = null;
tmp116_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp116_AST);
match(KW_LOGICAL);
break;
}
case KW_LOG:
{
k = LT(1);
k_AST = (Aast)astFactory.create(k);
astFactory.addASTChild(currentAST, k_AST);
match(KW_LOG);
k_AST.setType(KW_LOGICAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
mtype = OO_METH_LOGICAL;
}
else if ((LA(1)==KW_LONGCHAR) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp117_AST = null;
tmp117_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp117_AST);
match(KW_LONGCHAR);
mtype = OO_METH_LONGCHAR;
}
else if ((LA(1)==KW_MEMPTR) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp118_AST = null;
tmp118_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp118_AST);
match(KW_MEMPTR);
mtype = OO_METH_MEMPTR;
}
else if ((LA(1)==KW_POLY) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp119_AST = null;
tmp119_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp119_AST);
match(KW_POLY);
mtype = OO_METH_POLY;
}
else if ((LA(1)==KW_RAW) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp120_AST = null;
tmp120_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp120_AST);
match(KW_RAW);
mtype = OO_METH_RAW;
}
else if ((LA(1)==KW_RECID) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp121_AST = null;
tmp121_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp121_AST);
match(KW_RECID);
mtype = OO_METH_RECID;
}
else if ((LA(1)==KW_ROWID) && (_tokenSet_1.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
Aast tmp122_AST = null;
tmp122_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp122_AST);
match(KW_ROWID);
mtype = OO_METH_ROWID;
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_4.member(LA(2))) && (_tokenSet_38.member(LA(3)))) {
{
if ((LA(1)==KW_CLASS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_39.member(LA(3)))) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLASS);
hide(cl_AST);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_39.member(LA(2))) && (_tokenSet_37.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
mtype = OO_METH_CLASS;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
method_return_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_1);
}
returnAST = method_return_AST;
return mtype;
}
/**
* Matches the <code>EXTENT</code> keyword and the optional integer constant
* that follows it. Used by {@link #def_var_stmt} and the subtree is rooted
* by the <code>EXTENT</code> keyword.
*/
public final int extent() throws RecognitionException, TokenStreamException {
int size = -1;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast extent_AST = null;
Aast c_AST = null;
try { // for error handling
Aast tmp123_AST = null;
tmp123_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp123_AST);
match(KW_EXTENT);
size = -1;
{
if ((LA(1)==HEX_LITERAL||LA(1)==NUM_LITERAL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
whole_number_literal();
c_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
size = Integer.parseInt(c_AST.getText());
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
extent_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = extent_AST;
return size;
}
public final void destructor_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast destructor_stmt_AST = null;
Token p = null;
Aast p_AST = null;
Aast cl_AST = null;
try { // for error handling
Aast tmp124_AST = null;
tmp124_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp124_AST);
match(KW_DESTRUCT);
{
if ((LA(1)==KW_PUBLIC) && (_tokenSet_1.member(LA(2)))) {
p = LT(1);
p_AST = (Aast)astFactory.create(p);
match(KW_PUBLIC);
hide(p);
}
else if ((_tokenSet_1.member(LA(1))) && (LA(2)==LPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
any_symbol_at_all();
cl_AST = (Aast)returnAST;
hide(cl_AST);
lparens();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
block_term();
astFactory.addASTChild(currentAST, returnAST);
destructor_stmt_AST = (Aast)currentAST.root;
String mname = cl_AST.getText();
destructor_stmt_AST.putAnnotation("name", mname);
destructor_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = destructor_stmt_AST;
}
/**
* Implements the structure of a <code>FUNCTION</code> block definition
* which is the manner in which Progress implements a subroutine which can
* be called as part of an expression and which returns a value of a
* prespecified data type.
* <p>
* The most important feature of this rule is the direct usage of the
* {@link #symbol} rule to force the second token to a <code>SYMBOL</code>
* token type. This token is then used in the exit action to add the
* defined function's name to the function namespace.
* <p>
* Since each function has a prespecified return type, this type is
* stored in the function namespace as the token type associated with the
* specific function name that is added. This is then used as the token
* type for the root node of the subtree that represents a function call.
* In this manner, the expression evaluation can properly determine the
* data type of the return value for any defined or declared function.
* <p>
* All supported data types can be used as return types. Since the return
* type is provided back and stored an annotation, the tree associated with
* the return type is not needed and thus it is dropped.
* <p>
* This rule calls {@link #param_list_definition} to process the function parameters
* and add them to the variable dictionary.
* <p>
* Forward declarations are supported by returning <code>false</code> unless
* a forward declaration is detected by the presence of the
* <code>FORWARD</code> keyword. In such cases, the return value will change.
* <p>
* Note that in either case (normal definition or forward declaration), the
* function is added to the function namespace. This is exactly as Progress
* implements it, since this allows the function name to be referenced
* even if the definition has not occurred (a forward declaration). Note that
* it is perfectly legal to have the same function be forward declared AND
* then defined later in the source file. This causes the same function to
* be added twice to the function namespace, however there is only ever a
* single definition. The second addition, just overwrites the original
* forward declaration with the same information. This does not cause any
* problems but it may be implementation dependent. If the namespace
* implementation changes, this could be a problem in the future.
*
* @return Specifies whether or not this statement was a forward
* declaration. A forward declaration is one that has an option
* such as <code>FORWARD</code>, <code>IN SUPER</code> or
* <code>IN proc_handle</code> specified. Such declarations do
* not have associated blocks.
*/
public final boolean func_stmt() throws RecognitionException, TokenStreamException {
boolean fwd = false;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast func_stmt_AST = null;
Token fct = null;
Aast fct_AST = null;
Aast s_AST = null;
Aast fr_AST = null;
Aast pl_AST = null;
try { // for error handling
int ftype = -1;
int size = -1;
boolean privateAccess = false;
boolean save = false;
boolean in_super_or_h = false;
sym.setInMethod(true);
{
fct = LT(1);
fct_AST = (Aast)astFactory.create(fct);
astFactory.makeASTRoot(currentAST, fct_AST);
match(KW_FUNCT);
malformed_symbol();
s_AST = (Aast)returnAST;
hide(s_AST);
ftype=func_return();
fr_AST = (Aast)returnAST;
hide(fr_AST);
{
switch ( LA(1)) {
case KW_EXTENT:
{
size=extent();
astFactory.addASTChild(currentAST, returnAST);
func_stmt_AST = (Aast)currentAST.root;
if (size == -1 || size > 0) func_stmt_AST.putAnnotation("extent", Long.valueOf(size));
break;
}
case DOT:
case KW_IN:
case KW_MAP:
case KW_FORWARD:
case KW_PRIVATE:
case COLON:
case LPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_PRIVATE:
{
Aast tmp125_AST = null;
tmp125_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp125_AST);
match(KW_PRIVATE);
privateAccess = true;
break;
}
case DOT:
case KW_IN:
case KW_MAP:
case KW_FORWARD:
case COLON:
case LPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case LPARENS:
{
param_list_definition(true, true, false);
pl_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_MAP:
case KW_FORWARD:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_FORWARD:
{
Aast tmp126_AST = null;
tmp126_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp126_AST);
match(KW_FORWARD);
fwd = true; save = true;
break;
}
case KW_IN:
case KW_MAP:
{
{
switch ( LA(1)) {
case KW_MAP:
{
map_to_actual_name();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
in_super_or_in_handle();
astFactory.addASTChild(currentAST, returnAST);
fwd = true; in_super_or_h = true;
break;
}
case DOT:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (!( (ftype == FUNC_VOID ? (insideClass && in_super_or_h) : true) &&
(nestLevel < 2 || (insideClass && nestLevel == 2 && in_super_or_h)) ))
throw new SemanticException(" (ftype == FUNC_VOID ? (insideClass && in_super_or_h) : true) &&\n (nestLevel < 2 || (insideClass && nestLevel == 2 && in_super_or_h)) ");
block_term();
astFactory.addASTChild(currentAST, returnAST);
}
func_stmt_AST = (Aast)currentAST.root;
String qname = null;
String fname = s_AST.getText();
if (ftype == FUNC_CLASS)
{
qname = (String) fr_AST.getChildAt(0).getAnnotation("qualified");
}
sym.addFunction(fname, ftype, qname);
sym.annotateFunction(fname, func_stmt_AST, true);
// remember if the method should be private
if (privateAccess)
{
func_stmt_AST.putAnnotation("access", "private");
}
if (save)
{
// this is a forward function def, cache the local variable defs that
// correspond to the function parameter defs
sym.saveLocalVariables(fname);
}
else
{
if (!fwd && (pl_AST == null || pl_AST.getNumImmediateChildren() == 0))
{
// this is a non-forward function definition that has no parameters
// but it is possible that a previous matching forward definition
// did have parameters and those are implicitly implemented and allowed
// in the "concrete" definition; restore any cached vars here
if (sym.restoreLocalVariables(fname))
{
// remember that there was something to copy
func_stmt_AST.putAnnotation("implicit_parms", Boolean.valueOf(true));
}
}
else
{
// we don't need any cached values by this name, cleanup
sym.removeLocalVariables(fname);
}
}
sym.setInMethod(false);
func_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = func_stmt_AST;
return fwd;
}
/**
* Matches the optional <code>RETURNS</code> keyword and the required
* function return datatype (which is specified whether the
* <code>RETURNS</code> keyword is there or not. This is used by
* {@link #func_stmt} and is only separated to make the AST build
* correctly.
* <p>
* Undocumented is the fact that one can interchangeably use the
* <code>RETURN</code> here instead of the documented <code>RETURNS</code>.
* Both are matched but the token type is forced to <code>RETURNS</code>
* to simplify tree processing.
*
* @return The token type of the function's return value.
*/
public final int func_return() throws RecognitionException, TokenStreamException {
int ftype = -1;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast func_return_AST = null;
Token rs = null;
Aast rs_AST = null;
Token k = null;
Aast k_AST = null;
Token cl = null;
Aast cl_AST = null;
try { // for error handling
{
if ((LA(1)==KW_RETURNS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_40.member(LA(3)))) {
Aast tmp127_AST = null;
tmp127_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp127_AST);
match(KW_RETURNS);
}
else if ((LA(1)==KW_RETURN) && (_tokenSet_0.member(LA(2))) && (_tokenSet_40.member(LA(3)))) {
rs = LT(1);
rs_AST = (Aast)astFactory.create(rs);
astFactory.makeASTRoot(currentAST, rs_AST);
match(KW_RETURN);
rs_AST.setType(KW_RETURNS);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_40.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_CHAR) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp128_AST = null;
tmp128_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp128_AST);
match(KW_CHAR);
ftype = FUNC_CHAR;
}
else if ((LA(1)==KW_COM_HNDL) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp129_AST = null;
tmp129_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp129_AST);
match(KW_COM_HNDL);
ftype = FUNC_COM_HANDLE;
}
else if ((LA(1)==KW_DATE) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp130_AST = null;
tmp130_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp130_AST);
match(KW_DATE);
ftype = FUNC_DATE;
}
else if ((LA(1)==KW_DATETIME) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp131_AST = null;
tmp131_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp131_AST);
match(KW_DATETIME);
ftype = FUNC_DATETIME;
}
else if ((LA(1)==KW_DATE_TZ) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp132_AST = null;
tmp132_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp132_AST);
match(KW_DATE_TZ);
ftype = FUNC_DATETIME_TZ;
}
else if ((LA(1)==KW_DEC) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp133_AST = null;
tmp133_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp133_AST);
match(KW_DEC);
ftype = FUNC_DEC;
}
else if ((LA(1)==KW_INT) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp134_AST = null;
tmp134_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp134_AST);
match(KW_INT);
ftype = FUNC_INT;
}
else if ((LA(1)==KW_INT64) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp135_AST = null;
tmp135_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp135_AST);
match(KW_INT64);
ftype = FUNC_INT64;
}
else if ((LA(1)==KW_LOG||LA(1)==KW_LOGICAL) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_LOGICAL:
{
Aast tmp136_AST = null;
tmp136_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp136_AST);
match(KW_LOGICAL);
break;
}
case KW_LOG:
{
k = LT(1);
k_AST = (Aast)astFactory.create(k);
astFactory.addASTChild(currentAST, k_AST);
match(KW_LOG);
k_AST.setType(KW_LOGICAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
ftype = FUNC_LOGICAL;
}
else if ((LA(1)==KW_LONGCHAR) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp137_AST = null;
tmp137_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp137_AST);
match(KW_LONGCHAR);
ftype = FUNC_LONGCHAR;
}
else if ((LA(1)==KW_RECID) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp138_AST = null;
tmp138_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp138_AST);
match(KW_RECID);
ftype = FUNC_RECID;
}
else if ((LA(1)==KW_ROWID) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp139_AST = null;
tmp139_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp139_AST);
match(KW_ROWID);
ftype = FUNC_ROWID;
}
else if ((LA(1)==KW_HANDLE) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp140_AST = null;
tmp140_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp140_AST);
match(KW_HANDLE);
ftype = FUNC_HANDLE;
}
else if ((LA(1)==KW_WID_HAND) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp141_AST = null;
tmp141_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp141_AST);
match(KW_WID_HAND);
ftype = FUNC_HANDLE;
}
else if ((LA(1)==KW_RAW) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp142_AST = null;
tmp142_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp142_AST);
match(KW_RAW);
ftype = FUNC_RAW;
}
else if ((LA(1)==KW_MEMPTR) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp143_AST = null;
tmp143_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp143_AST);
match(KW_MEMPTR);
ftype = FUNC_MEMPTR;
}
else if ((LA(1)==KW_POLY) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp144_AST = null;
tmp144_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp144_AST);
match(KW_POLY);
ftype = FUNC_POLY;
}
else if ((LA(1)==KW_VOID) && (_tokenSet_42.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
Aast tmp145_AST = null;
tmp145_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp145_AST);
match(KW_VOID);
ftype = FUNC_VOID;
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_40.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
{
if ((LA(1)==KW_CLASS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_43.member(LA(3)))) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLASS);
hide(cl);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_43.member(LA(2))) && (_tokenSet_41.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
ftype = FUNC_CLASS;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
func_return_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_42);
}
returnAST = func_return_AST;
return ftype;
}
/**
* Matches the <code>MAP TO symbol</code> construct (the <code>TO</code>
* keyword is optional) in a {@link #func_stmt}. It is separated to improve
* the tree.
*/
public final void map_to_actual_name() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast map_to_actual_name_AST = null;
Token t = null;
Aast t_AST = null;
Aast actual_AST = null;
try { // for error handling
Aast tmp146_AST = null;
tmp146_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp146_AST);
match(KW_MAP);
{
if ((LA(1)==KW_TO)) {
t = LT(1);
t_AST = (Aast)astFactory.create(t);
match(KW_TO);
hide(t);
}
else if ((_tokenSet_15.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
symbol();
actual_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
map_to_actual_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_44);
}
returnAST = map_to_actual_name_AST;
}
/**
* Matches <code>IN SUPER</code> and <code>IN handle</code>
* clauses in a {@link #func_stmt}.
*/
public final void in_super_or_in_handle() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_super_or_in_handle_AST = null;
try { // for error handling
Aast tmp147_AST = null;
tmp147_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp147_AST);
match(KW_IN);
{
if ((LA(1)==KW_SUPER) && (LA(2)==DOT||LA(2)==COLON) && (_tokenSet_11.member(LA(3)))) {
Aast tmp148_AST = null;
tmp148_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp148_AST);
match(KW_SUPER);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
in_super_or_in_handle_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = in_super_or_in_handle_AST;
}
/**
* Parses any valid Progress 4GL expression and creates an AST that is
* suitable for evaluation. This is the main "entry point" for all Progress
* 4GL expression parsing. Progress expressions can contain sub-expressions
* and this entry point is properly recursive without causing any ambiguity.
* <p>
* The AST is structured with operator nodes as the root nodes and each
* operator (unary or binary) has the matching number of child nodes (1 or
* 2 respectively). Each child node is an operand and the semantics of
* left and right operands (for binary operators) is maintained.
* <p>
* The objective of all expression evaluation is to generate a single result
* of one of the possible Progress data types: integer, decimal, logical,
* date or character. The key point is that unless a Progress construct
* defines that it requires a literal (e.g. the <code>AS</code> clause for
* <code>DEFINE VARIABLE</code>), it is usually the case that an expression
* is allowed. It is always the case that there is some limit to the
* resulting data types that are allowed for the expression. Another way to
* say this is that many Progress constructs will require an expression of
* a specific type (e.g. the <code>MESSAGE</code> statement requires a
* character expression as its main data to be displayed). Since all valid
* expressions can be evaluated or resolved down to a specific data type,
* this is <b>the key</b> to building a consistent syntax for the Progress
* language. Since Progress expressions can contain lvalues, function calls,
* literals by themselves as well as part of a larger expression, none of
* the Progress constructs that reference expressions of a specific type
* need to worry about what is included or how it is parsed. As long as
* expressions are used, all of the variety of possible combinations are
* obtained "for free" because a common expression implementation
* is used. For this reason, this top level entry point is probably the
* most heavily referenced rule in this entire grammar. <b>Changes must be
* made very carefully!</b>
* <p>
* All of the Progress operators are supported and the precedence order is as follows:
* <pre>
* lowest OR (logical)
* | AND (logical)
* | OR (bitwise)
* | XOR (bitwise)
* | AND (bitwise)
* | NOT (logical)
* | NOT (bitwise)
* | =, EQ, <>, NE, <, LT, >, GT, ≤, LE, ≥, GE, MATCHES, BEGINS, CONTAINS
* | binary +, binary -
* | *, /, MODULO
* | unary +, unary -
* | DB_REF_NON_STATIC
* | COLON (used as an invocation mechanism)
* highest ( )
* </pre>
* <p>
* Note that CONTAINS is only documented for use within a <code>WHERE</code>
* clause, see {@link #record_phrase} and {@link #where_clause}.
* <p>
* The key problems that had to be solved for this implementation included:
* <ul>
* <li> Structuring the rules to implement the proper precedence AND to
* properly build a tree that could be correctly evaluated.
* <li> Ensuring that expressions properly nest (through recursion).
* <li> Eliminating ambiguity that would defeat the parser's lookahead
* mechanisms.
* </ul>
* <p>
* To handle the precedence issue, each precedence level (see the table
* above) is handled in a separate rule. Starting at in this top level
* entry point, the lowest precedence rule is referenced. This reference is
* made with an optional <code>KW_OR</code> operator. If thus operator is
* present, it is the root of the resulting tree. This means it is the
* last operator to be evaluated since its operands will be evaluated
* first. This is the proper definition of lowest precedence. If this
* operator is present, then a second operand is expected.
* <p>
* The only exceptions to this structure are the bitwise OR, AND and NOT
* which don't actually conflict with the existing logical versions. For
* simplicity purposes, we simply match on the logical operator here. In
* other words the tree would look the same so we are taking a shortcut.
* The negative implication here is that the token type of the bitwise
* versions is the same as the logical versions, but this is also the case
* for the binary + and - operators which are actually 3 different operations
* for numbers, dates and datetime values.
* <p>
* Each precedence level is similarly constructed, the left operand being
* required, all operators being optional and each operator choice an equal
* alternative. If any of the operators exists, then it is the root of the
* subtree and a right operand is expected. This hold true for all rules
* that process binary operators. Please note that this left-mandatory
* and optional right side (operator + right operand) is critical for
* allowing an expression to be as simple as a single lvalue (variable or
* field name), function call or literal. Alternatively, it can expand into
* a highly nested set of recursively parsed expressions that all evaluate
* to a single scalar result of one of the known Progress data types.
* <p>
* At the bottom of the hierarchy of rules are unary operators, these
* are implemented as an optional prefix operator and a mandatory right
* operand.
* <p>
* The final level is the primary expression. This is where the precedence
* operator parenthesis is handled. It also is where we allow a single
* lvalue, literal or function reference. While the literals are fairly
* easily defined, lvalues and functions are complicated by the fact that
* they are used defined symbols and there is inherent ambiguity in the
* definitions for each of these. See {@link #lvalue} and {@link #func_call}
* for more details on how this is resolved.
* <p>
* This rule is designed to allow recursion (the highest precedence levels
* {@link #func_call} and {@link #primary_expr} reference this rule again,
* allowing infinite nesting of sub-expressions, with proper parsing,
* evaluation and tree building.
* <p>
* Ambiguity is primary caused by the potential overlap in the rules
* referenced from {@link #primary_expr}. This is caused by the fact that
* multiple rule references made there must all allow for a user-defined
* symbol to appear in the token stream. Multiple rules all requiring
* the same definition to appear is the definition of <b>ambiguity</b>!
* See that rule for more details on the solution.
* <p>
* To the extent that is feasible, syntax checking is implemented in the
* expression processing, however there is one important area of checking
* that cannot be properly specified using the structure of the parser:
* operand data type checking. For this reason, such checking (when it is
* implemented) will be built using validating semantic predicates. The need
* for this checking is limited based on the assumption that all input is
* a valid Progress 4GL source file.
* <p>
* <code>ExpressionEvaluator</code> is dependent upon this entry
* point.
* <p>
* Note that there is an ambiguity caused between the <code>OR</code> keyword
* implemented in <code>expr</code> and by the use of the <code>OR</code>
* keyword in a <code>WHEN</code> clause (additional WHEN conditions can
* be added to the same statement using an <code>OR WHEN condition</code>
* syntax). Since the following condition is an expression, one must detect
* the use of the following <code>WHEN</code> as the next token after the
* <code>OR</code> to disambiguate. The <code>expr</code> rule which
* implements the logical <code>OR</code> processing thus uses a semantic
* predicate to terminate expression processing (and not match on the
* <code>OR</code> in the case where lookahead 2 is the reserved keyword
* <code>WHEN</code>. Ambiguity warnings are disabled since this trick
* resolves the issue.
* <p>
* When this is called from a parser that is invoked with the top level
* entry point {@link #external_proc}, this rule will root the resulting
* subtree in an artificial token <code>EXPRESSION</code>. Otherwise, this
* method is used directly and no artificial root is created.
* <p>
* The {link #log_and_expr} is called as the only rule reference. This rule
* matches both logical and bitwise OR.
*/
public final void expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast expr_AST = null;
Aast lae_AST = null;
Token kwo = null;
Aast kwo_AST = null;
try { // for error handling
// tracks the re-entrancy of this rule, if this is 0 on entry, then
// this has been no recursion yet...
exprLvl++;
log_and_expr();
lae_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop1643:
do {
if (((LA(1)==KW_OR) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(2) != KW_WHEN )) {
kwo = LT(1);
kwo_AST = (Aast)astFactory.create(kwo);
astFactory.makeASTRoot(currentAST, kwo_AST);
match(KW_OR);
if (isEnum(lae_AST))
{
saveAndReplaceType(kwo_AST, BITWISE_OR);
}
checkExtraSpace(kwo_AST, false);
matchAssign = false;
log_and_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1643;
}
} while (true);
}
expr_AST = (Aast)currentAST.root;
// only make an artificial root at the first entry into this rule
// (as opposed to subsequent recursive entries) and if the parser
// is operating from the top level entry point
if (topLevelEntry && exprLvl == 1 && !skipExpression)
{
expr_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(EXPRESSION,"expression")).add(expr_AST));
}
if (!skipExpression)
{
exprLvl--;
}
currentAST.root = expr_AST;
currentAST.child = expr_AST!=null &&expr_AST.getFirstChild()!=null ?
expr_AST.getFirstChild() : expr_AST;
currentAST.advanceChildToEnd();
expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = expr_AST;
}
/**
* Matches all possible user-defined symbol names. A very important element
* of this approach is that the set <b>must include unreserved keywords</b>.
* This is important since this rule is referenced in many different parser
* rules in order to add this set to the lookahead list for various
* alternatives. Since the lexer defaults all symbols to the more specific
* token type (if they match an unreserved keyword), one will only encounter
* a <code>SYMBOL</code> token type if there is no overlap with the
* unreserved keyword namespace. In other words, since the text
* "char" matches both an unreserved keyword and a possible valid
* user-defined symbol, the lexer will default the token type to
* <code>KW_CHAR</code>. This is critical since the number of places in the
* parser that expect a real <code>SYMBOL</code> type are few and the token
* type can be overridden based on context. If the reverse bias was made in
* the lexer, then it would be virtually impossible to implement the parser
* because Progress is both very keyword driven and highly context sensitive.
* This means that the number of places in the parser that depend upon a
* keyword match is significantly higher than those that expect a symbol
* match. Thus we bias the token types toward keywords and then override
* the type in the few places where we <b>know</b> (based on context) that
* the next token is a <code>SYMBOL</code> rather than a keyword.
* <p>
* This rule enables those explicit overrides and it is only used in the
* following cases:
* <ul>
* <li> The calling rule expects the next token to be a <code>SYMBOL</code>
* token type rather than a keyword. An example is a
* <code>DEFINE VARIABLE</code> statement, where must be a symbol
* type and cannot be a keyword, even though in any keyword conflict
* the lexer defaults to the keyword type. This is handled by the
* init code of this method which rewrites the token type to be a
* <code>SYMBOL</code> if all of the following are true (in all other
* cases an exception is thrown):
* <ul>
* <li> The token type is not already <code>SYMBOL</code>.
* <li> There is a keyword conflict.
* <li> The keyword is unreserved.
* </ul>
* <li> The calling rule requires that its lookahead prediction include
* the set of all possible user-defined symbols, in order to ensure
* that the top level parser rules will properly select and invoke
* the calling rule <b>but the calling rule itself rewrites the
* token type and is designed to never actually invoke the
* <code>symbol</code> rule itself</b>. In this case, we refer to
* this as using <code>symbol</code> for "pull" purposes
* only. This trick is critical for making the {@link #lvalue} and
* {@link #func_call} rules work!
* </ul>
* <p>
* One more trick is used here to ensure that the set of all possible input
* token types is matched. Since all of the unreserved keywords are
* assigned artificial token types from a list maintained in the parser,
* it is designed such that all of these token types are created in a
* contiguous set that is bounded by <code>BEGIN_UNRESERVED</code> and
* <code>END_UNRESERVED</code> token types. This trick allows this rule to
* add the set of all unreserved keywords to the rule by specifying a
* range starting and ending with these token types. Note that ANTLR does
* generate a <code>matchRange</code> call from this grammar but it does not
* actually generate or provide the backing method! Such a method was added
* manually to satisfy this requirement.
* <p>
* It is very important to note that any actual invocation of this rule
* (in cases where this isn't only used in pull mode) will cause the token
* type to be rewritten as <code>SYMBOL</code> or an exception to be
* thrown. No other alternative will result, no matter what the actual
* token type is on input. Only call this rule if this is the expected
* behavior or if pull mode is being used. In the case of pull mode, it
* is critical that the calling rule rewrite the token type in an init action
* to ensure that the token type never causes an actual invocation of this
* rule.
*/
public final void symbol() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast symbol_AST = null;
try { // for error handling
if (LA(1) != SYMBOL)
{
Keyword found = sym.lookupKeyword(LT(1).getText());
if (found != null && !found.isReserved())
{
LT(1).setType(SYMBOL);
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==SYMBOL)) {
Aast tmp149_AST = null;
tmp149_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp149_AST);
match(SYMBOL);
}
else if (((LA(1) >= BEGIN_UNRESERVED && LA(1) <= END_UNRESERVED))) {
Aast tmp150_AST = null;
tmp150_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp150_AST);
matchRange(BEGIN_UNRESERVED,END_UNRESERVED);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
symbol_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = symbol_AST;
}
/**
* Implements the reserved_or_symbol rule which matches symbols and reserved
* or nonreserved keywords that have to be handled as symbols. It converts
* matched tokens into SYMBOL type ones for consistency of the UAST.
*/
public final void reserved_or_symbol() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast reserved_or_symbol_AST = null;
try { // for error handling
int oldtype = -1;
if (LA(1) != SYMBOL)
{
oldtype = LA(1);
LT(1).setType(SYMBOL);
}
{
if (((LA(1) >= BEGIN_RESERVED && LA(1) <= END_RESERVED))) {
Aast tmp151_AST = null;
tmp151_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp151_AST);
matchRange(BEGIN_RESERVED,END_RESERVED);
}
else if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
reserved_or_symbol_AST = (Aast)currentAST.root;
// save off original type from before token rewriting
if (oldtype != -1)
reserved_or_symbol_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
reserved_or_symbol_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = reserved_or_symbol_AST;
}
/**
* Matches the <code>DEFINE</code> Progress 4GL language statement and
* switches into the correct alternative based on the lookahead tokens.
* <p>
* This rule is called by {@link #stmt_list} and it handles the matching
* for the <code>DEFINE</code> keyword, the optional shared scope keywords
* <code>NEW, GLOBAL, SHARED</code> and the optional keywords for parameter
* types <code>INPUT, OUTPUT, INPUT-OUTPUT and RETURN</code>. It then
* calls the appropriate alternative to allow the specific processing to
* occur. The alternatives:
* <ul>
* <li> BROWSE {@link #def_browse_stmt}
* <li> BUTTON {@link #def_button_stmt}
* <li> BUFFER {@link #def_buf_stmt}
* <li> DATASET {@link #def_dataset_stmt}
* <li> DATA-SOURCE {@link #def_datasrc_stmt}
* <li> EVENT {@link #def_event_stmt}
* <li> FRAME {@link #def_frame_stmt}
* <li> IMAGE {@link #def_image_stmt}
* <li> MENU and SUB-MENU {@link #def_menu_stmt}
* <li> PARAMETER {@link #def_parm_stmt}
* <li> PROPERTY {@link #def_prop_stmt}
* <li> RECTANGLE {@link #def_rect_stmt}
* <li> STREAM {@link #def_stream_stmt}
* <li> QUERY {@link #def_query_stmt}
* <li> TEMP-TABLE (and WORK-TABLE/WORKFILE) {@link #def_temp_table_stmt}
* <li> VARIABLE {@link #def_var_stmt}
* </ul>
* <p>
* This design allows all <code>DEFINE</code> statements to be supported
* without ambiguity because it left-factors the common keyword.
*/
public final void define_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast define_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Aast am_AST = null;
Token st = null;
Aast st_AST = null;
Token ab = null;
Aast ab_AST = null;
Token ov = null;
Aast ov_AST = null;
Aast t_AST = null;
Token k1 = null;
Aast k1_AST = null;
Token k2 = null;
Aast k2_AST = null;
Token k3 = null;
Aast k3_AST = null;
Token k4 = null;
Aast k4_AST = null;
try { // for error handling
int mtype = -1;
String varname = null;
String dsName = null;
String tablename = null;
boolean force = false;
boolean fakeBuffer = false;
Aast likeast = null;
String likename = null;
boolean tt_new = false;
boolean tt_global = false;
boolean tt_shared = false;
boolean saveInStatic = inStaticCtxt;
boolean[] allowColon = new boolean[] { false };
Object[] df = null;
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DEFINE);
{
_loop164:
do {
switch ( LA(1)) {
case KW_PK_PRIV:
case KW_PK_PROT:
case KW_PRIVATE:
case KW_PROTECTD:
case KW_PUBLIC:
{
access_mode();
am_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SERIALAB:
{
Aast tmp152_AST = null;
tmp152_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp152_AST);
match(KW_SERIALAB);
break;
}
case KW_NON_SER:
{
Aast tmp153_AST = null;
tmp153_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp153_AST);
match(KW_NON_SER);
break;
}
case KW_STATIC:
{
st = LT(1);
st_AST = (Aast)astFactory.create(st);
astFactory.addASTChild(currentAST, st_AST);
match(KW_STATIC);
inStaticCtxt = true;
break;
}
case KW_ABSTRACT:
{
ab = LT(1);
ab_AST = (Aast)astFactory.create(ab);
astFactory.addASTChild(currentAST, ab_AST);
match(KW_ABSTRACT);
break;
}
case KW_OVERRIDE:
{
ov = LT(1);
ov_AST = (Aast)astFactory.create(ov);
astFactory.addASTChild(currentAST, ov_AST);
match(KW_OVERRIDE);
break;
}
case KW_FINAL:
{
Aast tmp154_AST = null;
tmp154_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp154_AST);
match(KW_FINAL);
break;
}
default:
{
break _loop164;
}
}
} while (true);
}
{
switch ( LA(1)) {
case KW_DATA_SRC:
case KW_DATASET:
case KW_FRAME:
case KW_NEW:
case KW_QUERY:
case KW_SHARED:
case KW_STREAM:
case KW_WORK_TAB:
case KW_BROWSE:
case KW_BUFFER:
case KW_MENU:
case KW_SUB_MENU:
case KW_TEMP_TAB:
case KW_VAR:
{
{
if (((LA(1)==KW_NEW||LA(1)==KW_SHARED))&&( am_AST == null )) {
{
switch ( LA(1)) {
case KW_NEW:
{
Aast tmp155_AST = null;
tmp155_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp155_AST);
match(KW_NEW);
{
switch ( LA(1)) {
case KW_GLOBAL:
{
Aast tmp156_AST = null;
tmp156_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp156_AST);
match(KW_GLOBAL);
tt_global = true;
break;
}
case KW_SHARED:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
tt_new = true;
break;
}
case KW_SHARED:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp157_AST = null;
tmp157_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp157_AST);
match(KW_SHARED);
tt_shared = true;
}
else if ((_tokenSet_7.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_BROWSE:
{
varname=def_browse_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BROWSE);
break;
}
case KW_BUFFER:
{
def_buf_stmt(true, false, (tt_shared && ! tt_new), am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BUFFER);
break;
}
case KW_DATASET:
{
dsName=def_dataset_stmt(am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_DATASET);
// add the dataset to the namespace
sym.addDataSet(dsName, DATA_SET, d_AST, am_AST, st_AST);
break;
}
case KW_DATA_SRC:
{
dsName=def_datasrc_stmt(am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_DATA_SOURCE);
// add the data source to the namespace
sym.addDataSource(dsName, DATA_SOURCE, d_AST, am_AST, st_AST);
break;
}
case KW_FRAME:
{
df=def_frame_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_FRAME);
String frame = (String) df[0];
Aast fp = (Aast) df[1];
setUseDictExps(frame, fp, d_AST);
break;
}
case KW_MENU:
case KW_SUB_MENU:
{
mtype=def_menu_stmt();
astFactory.addASTChild(currentAST, returnAST);
define_stmt_AST = (Aast)currentAST.root;
if (mtype == WID_MENU)
{
d_AST.setType(DEFINE_MENU);
}
else
{
d_AST.setType(DEFINE_SUB_MENU);
}
varname = define_stmt_AST.getImmediateChild(SYMBOL, null).getText();
likeast = define_stmt_AST.getImmediateChild(KW_LIKE, null);
if (likeast != null)
{
likename = likeast.getImmediateChild(SYMBOL, null).getText();
sym.addMenuLike(varname, likename, define_stmt_AST);
}
break;
}
case KW_QUERY:
{
def_query_stmt(am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_QUERY);
break;
}
case KW_STREAM:
{
def_stream_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_STREAM);
break;
}
case KW_WORK_TAB:
case KW_TEMP_TAB:
{
tablename=def_temp_table_stmt(tt_new, tt_global, tt_shared, am_AST, st_AST);
t_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
fakeBuffer = true;
if (t_AST.getType() == KW_TEMP_TAB)
{
d_AST.setType(DEFINE_TEMP_TABLE);
}
else
{
d_AST.setType(DEFINE_WORK_TABLE);
}
break;
}
case KW_VAR:
{
varname=def_var_stmt(allowColon, d_AST, am_AST, st_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_VARIABLE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_INPUT:
case KW_IN_OUT:
case KW_OUTPUT:
case KW_PARM:
case KW_RETURN:
{
{
switch ( LA(1)) {
case KW_INPUT:
{
k1 = LT(1);
k1_AST = (Aast)astFactory.create(k1);
astFactory.addASTChild(currentAST, k1_AST);
match(KW_INPUT);
break;
}
case KW_OUTPUT:
{
k2 = LT(1);
k2_AST = (Aast)astFactory.create(k2);
astFactory.addASTChild(currentAST, k2_AST);
match(KW_OUTPUT);
break;
}
case KW_IN_OUT:
{
k3 = LT(1);
k3_AST = (Aast)astFactory.create(k3);
astFactory.addASTChild(currentAST, k3_AST);
match(KW_IN_OUT);
break;
}
case KW_RETURN:
{
k4 = LT(1);
k4_AST = (Aast)astFactory.create(k4);
astFactory.addASTChild(currentAST, k4_AST);
match(KW_RETURN);
break;
}
case KW_PARM:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
varname=def_parm_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_PARAMETER);
if (k1_AST == null && k2_AST == null && k3_AST == null && k4_AST == null)
{
force = true;
}
break;
}
case KW_PROPERTY:
{
varname=def_prop_stmt(d_AST, am_AST, st_AST, ov_AST, ab_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_PROPERTY);
break;
}
case KW_EVENTS:
{
varname=def_event_stmt(d_AST, am_AST, st_AST, ov_AST, ab_AST);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_EVENT);
break;
}
case KW_BUTTON:
{
varname=def_button_stmt(allowColon);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_BUTTON);
break;
}
case KW_RECT:
{
varname=def_rect_stmt(allowColon);
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_RECTANGLE);
break;
}
case KW_IMAGE:
{
varname=def_image_stmt();
astFactory.addASTChild(currentAST, returnAST);
d_AST.setType(DEFINE_IMAGE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==COLON))&&( allowColon[0] )) {
colon();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
define_stmt_AST = (Aast)currentAST.root;
inStaticCtxt = saveInStatic;
if (varname != null)
{
postDefineVar(varname, define_stmt_AST, am_AST, st_AST, force);
}
if (dsName != null)
{
sym.setDatasetOptions(null, false, dsName, define_stmt_AST, d_AST.getType(), true);
}
if (fakeBuffer)
{
postDefineBuf(tablename, define_stmt_AST);
}
define_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = define_stmt_AST;
}
/**
* Matches a <code>DEFINE BROWSE</code> Progress 4GL language statement.
* This is the statement that defines or imports a new user-named browse
* widget.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* browses. This rule supports shared or local buffers and the syntax for
* both declaring or defining (<code>NEW</code> keyword) shared buffers.
* HOWEVER, all the matching for these optional keywords is done in the
* <code>define_stmt</code> rule. This refactoring allows all
* <code>DEFINE</code> statements to be supported without ambiguity.
* <p>
* This rule matches the <code>BROWSE</code> keyword and all subsequent
* processing. Calls {@link #symbol}, {@link #query_reference} and
* {@link #column_spec} rules.
* <p>
* This rule adds the browse's name to the widget namespace.
* <p>
* Supports the Progress undocumented feature that the query_reference and
* the column_spec can be optional (missing). But even if they are missing,
* the {@link #browse_options_phrase} can still be included. For this reason,
* the browse_options_phrase is directly referenced instead of being included
* at the end of the column_spec.
* <p>
* @return The variable name of the browse that was defined.
*/
public final String def_browse_stmt() throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_browse_stmt_AST = null;
Token br = null;
Aast br_AST = null;
Aast b_AST = null;
try { // for error handling
{
br = LT(1);
br_AST = (Aast)astFactory.create(br);
match(KW_BROWSE);
hide(br);
symbol();
b_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// this must be done here (as soon as the symbol is processed
// since the browse name can be referenced later in the same
// language stmt and so the namespace must include this widget
// (e.g. a validate() option in the column_spec is one example
// of how it could be referenced)
varname = b_AST.getText();
sym.addWidget(varname, WID_BROWSE);
{
if ((((LA(1) >= FILEROOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_DISP && LA(1) != KW_WITH )) {
query_reference();
astFactory.addASTChild(currentAST, returnAST);
{
_loop188:
do {
if ((LA(1)==KW_EXC_LOCK||LA(1)==KW_NO_LOCK||LA(1)==KW_SH_LOCK) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SH_LOCK:
{
Aast tmp158_AST = null;
tmp158_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp158_AST);
match(KW_SH_LOCK);
break;
}
case KW_EXC_LOCK:
{
Aast tmp159_AST = null;
tmp159_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp159_AST);
match(KW_EXC_LOCK);
break;
}
case KW_NO_LOCK:
{
Aast tmp160_AST = null;
tmp160_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp160_AST);
match(KW_NO_LOCK);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_WAIT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp161_AST = null;
tmp161_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp161_AST);
match(KW_NO_WAIT);
}
else {
break _loop188;
}
} while (true);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==KW_DISP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_DISP )) {
{
column_spec();
astFactory.addASTChild(currentAST, returnAST);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
_loop192:
do {
if ((LA(1)==KW_WITH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
browse_options_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop192;
}
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
def_browse_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_browse_stmt_AST;
return varname;
}
/**
* Matches the <code>DEFINE DATASET</code> language statement.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional access modes or sharing
* options.
* <p>
* This rule matches the <code>DATASET</code> keyword and a following
* {@link #symbol}. The {@link #namespace_clause} can be matched optionally.
* Then there is always a match to {@link #for_record_spec}. At the end is
* the use of {@link #data_relation}.
* <p>
* The dataset name will be added to a unique namespace such that the
* dataset can be referenced as a handle and provided as a parameter.
* <p>
* Customer source code shows the DATA-RELATION is optional even though the
* Progress docs state otherwise. This must be an undocumented feature.
*
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
*
* @return The legacy name of the dataset defined.
*/
public final String def_dataset_stmt(
Aast am, Aast st
) throws RecognitionException, TokenStreamException {
String dsname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_dataset_stmt_AST = null;
Token ds = null;
Aast ds_AST = null;
Aast d_AST = null;
Aast f_AST = null;
try { // for error handling
int idx = 1;
int pidx = 1;
ds = LT(1);
ds_AST = (Aast)astFactory.create(ds);
match(KW_DATASET);
hide(ds);
symbol();
d_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
dsname = d_AST.getText();
{
_loop213:
do {
switch ( LA(1)) {
case KW_NAMESP_P:
case KW_NAMESP_U:
{
namespace_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_XML_NNAM:
{
xml_node_name();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_XML_NTYP:
{
xml_node_type();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SERIALZN:
{
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SERIALZH:
{
Aast tmp162_AST = null;
tmp162_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp162_AST);
match(KW_SERIALZH);
break;
}
case KW_REF_ONLY:
{
Aast tmp163_AST = null;
tmp163_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp163_AST);
match(KW_REF_ONLY);
break;
}
default:
{
break _loop213;
}
}
} while (true);
}
for_record_spec(false, false, false);
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop215:
do {
if ((LA(1)==KW_DATA_REL) && (_tokenSet_45.member(LA(2))) && (_tokenSet_46.member(LA(3)))) {
data_relation(idx);
astFactory.addASTChild(currentAST, returnAST);
idx++;
}
else if ((LA(1)==KW_PAR_IREL) && (_tokenSet_45.member(LA(2))) && (_tokenSet_46.member(LA(3)))) {
parent_id_relation(pidx);
astFactory.addASTChild(currentAST, returnAST);
pidx++;
}
else {
break _loop215;
}
} while (true);
}
Aast child = (Aast) f_AST.getFirstChild();
String signature = "";
while (child != null)
{
int type = child.getType();
if (type == BUFFER || type == TEMP_TABLE)
{
String s = (String) child.getAnnotation("db_signature");
if (s == null)
{
String err = String.format("Missing 'db_signature' for record: %s", child.dumpTree());
throw new RuntimeException(err);
}
signature += "<" + s + ">";
}
child = (Aast) child.getNextSibling();
}
if (signature.length() == 0)
{
String err2 = String.format("Empty 'db_signature' for dataset: %s", ds_AST.dumpTree());
throw new RuntimeException(err2);
}
// annotate the SYMBOL node in the definition (will be the first child of DEFINE_DATASET)
d_AST.putAnnotation("db_signature", signature);
def_dataset_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_dataset_stmt_AST;
return dsname;
}
/**
* Matches the <code>DEFINE DATA-SOURCE</code> language statement.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional access modes or sharing
* options.
* <p>
* This rule matches the <code>DATA-SOURCE</code> keyword and a following
* {@link #symbol}. Then there can be a match to {@link #query_reference}
* or multiple {@link #source_buffer_phrase} references.
* <p>
* The data source name will be added to a unique namespace such that the
* data source can be referenced as a handle and provided as a parameter.
*
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
*
* @return The legacy name of the data source defined.
*/
public final String def_datasrc_stmt(
Aast am, Aast st
) throws RecognitionException, TokenStreamException {
String daname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_datasrc_stmt_AST = null;
Token ds = null;
Aast ds_AST = null;
Aast d_AST = null;
try { // for error handling
ds = LT(1);
ds_AST = (Aast)astFactory.create(ds);
match(KW_DATA_SRC);
hide(ds);
symbol();
d_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
daname = d_AST.getText();
Aast tmp164_AST = null;
tmp164_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp164_AST);
match(KW_FOR);
{
{
if ((((LA(1) >= FILEROOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_QUERY )) {
query_reference();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((_tokenSet_13.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
source_buffer_phrase();
astFactory.addASTChild(currentAST, returnAST);
{
_loop221:
do {
if ((LA(1)==COMMA) && (_tokenSet_13.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
comma();
astFactory.addASTChild(currentAST, returnAST);
source_buffer_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop221;
}
} while (true);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
def_datasrc_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_datasrc_stmt_AST;
return daname;
}
/**
* Matches a <code>DEFINE FRAME</code> Progress 4GL language statement
* which is nearly identical to the {@link #form_stmt}.
* <p>
* The tricky part of this statement is handling the options in any order and
* resolving the ambiguity between the record and field specifications.
* Records are disambiguated from fields (records take precedence when there
* is a name conflict) by trying to do a lookup, if it fails the record is
* no matched (see {@link #record_spec}) and instead the {@link #form_item}
* is checked. By carefully ordering of these options and using a semantic
* predicate, the ambiguity is resolved. For this reason, ambiguity warnings
* have been disabled.
* <p>
* Called by {@link #define_stmt}. Uses {@link #record_spec},
* {@link #form_item} and {@link #frame_phrase} to properly build the AST.
*
* @return An array with index 0 the frame name and on index 1 the frame_phrase AST.
*/
public final Object[] def_frame_stmt() throws RecognitionException, TokenStreamException {
Object[] d = new Object[2];
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_frame_stmt_AST = null;
Token fr = null;
Aast fr_AST = null;
Aast f_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
boolean hadFormItem = false;
boolean hadRecord = false;
boolean hadHeader = false;
fr = LT(1);
fr_AST = (Aast)astFactory.create(fr);
match(KW_FRAME);
hide(fr);
malformed_symbol();
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop284:
do {
if ((LA(1)==KW_DROP_TAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp165_AST = null;
tmp165_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp165_AST);
match(KW_DROP_TAR);
}
else if ((LA(1)==KW_BACKGRND||LA(1)==KW_HEADER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_HEADER:
{
Aast tmp166_AST = null;
tmp166_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp166_AST);
match(KW_HEADER);
break;
}
case KW_BACKGRND:
{
Aast tmp167_AST = null;
tmp167_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp167_AST);
match(KW_BACKGRND);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
hadHeader = true;
}
else if (((_tokenSet_13.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( (LA(2) == DOT || LA(2) == KW_WITH || LA(2) == KW_HEADER || LA(2) == KW_BACKGRND) &&
!hadFormItem &&
!hadHeader &&
isRecord(LT(1).getText()) )) {
record_spec(fields);
astFactory.addASTChild(currentAST, returnAST);
hadRecord = true;
}
else if (((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!(LA(1) == DOT || LA(1) == KW_WITH || LA(1) == KW_HEADER || LA(1) == KW_BACKGRND) &&
(!hadRecord || hadHeader)
)) {
form_item(fields);
astFactory.addASTChild(currentAST, returnAST);
hadFormItem = true;
}
else if ((LA(1)==KW_WITH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop284;
}
} while (true);
}
String frame = f_AST.getText();
sym.addFrame(frame, WID_FRAME);
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
d[0] = frame;
d[1] = fp_AST;
def_frame_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_frame_stmt_AST;
return d;
}
/**
* Matches a <code>DEFINE MENU or DEFINE SUB-MENU</code> Progress 4GL
* language statement. This is the statement that defines user-named
* menus and sub-menus. Menus are stored in their own namespace which is
* separate from the other widgets.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword.
* <p>
* This rule matches the <code>MENU or SUB-MENU</code> keywords and all
* subsequent processing. Calls the following rules:
* <p>
* {@link #symbol}
* {@link #ui_stuff}
* {@link #simple_title_string}
* {@link #like_menu_clause}
* {@link #menu_element_descriptor}
* <p>
* All options can be processed in any order.
* <p>
* An undocumented "feature" (found in customer code) is that Progress will
* ignore a <code>DOT</code> in between <code>MENU-ITEM</code> clauses. In
* other words, it will silently drop that extra character if the period
* is followed by the <code>MENU-ITEM</code> or <code>RULE</code> keywords.
* Presumably, the <code>SUB-MENU</code> and <code>SKIP</code> keywords also
* have this effect but it hasn't been confirmed yet.
*/
public final int def_menu_stmt() throws RecognitionException, TokenStreamException {
int mtype = -1;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_menu_stmt_AST = null;
Token me = null;
Aast me_AST = null;
Token sub = null;
Aast sub_AST = null;
Aast m_AST = null;
try { // for error handling
mtype = WID_MENU;
{
switch ( LA(1)) {
case KW_MENU:
{
me = LT(1);
me_AST = (Aast)astFactory.create(me);
match(KW_MENU);
hide(me);
break;
}
case KW_SUB_MENU:
{
sub = LT(1);
sub_AST = (Aast)astFactory.create(sub);
match(KW_SUB_MENU);
hide(sub);
mtype = WID_SUB_MENU;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
symbol();
m_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop258:
do {
if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TITLE||LA(1)==KW_MENU_BAR||LA(1)==KW_SUB_M_H) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_MENU_BAR:
{
Aast tmp168_AST = null;
tmp168_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp168_AST);
match(KW_MENU_BAR);
break;
}
case KW_SUB_M_H:
{
Aast tmp169_AST = null;
tmp169_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp169_AST);
match(KW_SUB_M_H);
break;
}
case KW_TITLE:
{
simple_title_string();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_48.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_LIKE:
{
like_menu_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SKIP:
case KW_MENU_ITM:
case KW_RULE:
case KW_SUB_MENU:
{
menu_element_descriptor();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((LA(1)==DOT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( (LA(2) == KW_MENU_ITM && LA(4) != COLON) ||
(LA(2) == KW_SUB_MENU && LA(4) != COLON) ||
LA(2) == KW_RULE || LA(2) == KW_SKIP )) {
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop258;
}
} while (true);
}
sym.addMenu(m_AST.getText(), mtype);
def_menu_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_menu_stmt_AST;
return mtype;
}
/**
* Matches a <code>DEFINE QUERY</code> Progress 4GL language statement.
* This is the statement that defines or imports a new user-named query.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* browses. This rule supports shared or local buffers and the syntax for
* both declaring or defining (<code>NEW</code> keyword) shared buffers.
* HOWEVER, all the matching for these optional keywords is done in the
* <code>define_stmt</code> rule. This refactoring allows all
* <code>DEFINE</code> statements to be supported without ambiguity.
* <p>
* This rule matches the <code>QUERY</code> keyword and all subsequent
* processing. Calls {@link #malformed_symbol}, {@link #for_record_spec} and
* {@link #cache_records} rules.
*
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
*/
public final void def_query_stmt(
Aast am, Aast st
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_query_stmt_AST = null;
Aast q_AST = null;
try { // for error handling
Aast tmp170_AST = null;
tmp170_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp170_AST);
match(KW_QUERY);
malformed_symbol();
q_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
for_record_spec(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
_loop195:
do {
if ((LA(1)==KW_CACHE) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
cache_records();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SCROLLIN) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp171_AST = null;
tmp171_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp171_AST);
match(KW_SCROLLIN);
}
else if ((LA(1)==KW_RCOD_INF) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp172_AST = null;
tmp172_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp172_AST);
match(KW_RCOD_INF);
}
else {
break _loop195;
}
} while (true);
}
sym.addQuery(q_AST.getText(), q_AST, QUERY, am, st);
def_query_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_query_stmt_AST;
}
/**
* Matches a <code>DEFINE STREAM</code> Progress 4GL language statement.
* This is the statement that defines or imports new user-named stream.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* buffers. This rule supports shared or local buffers and the syntax for
* both declaring or defining (<code>NEW</code> keyword) shared buffers.
* HOWEVER, all the matching for these optional keywords is done in the
* <code>define_stmt</code> rule. This refactoring allows all
* <code>DEFINE</code> statements to be supported without ambiguity.
* <p>
* This rule matches the <code>STREAM</code> keyword and the required
* stream name. This rule is similar to the {@link #lvalue}
* but it is separated such that namespace additions can be done without
* impacting that rule.
*/
public final void def_stream_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_stream_stmt_AST = null;
Aast stream_AST = null;
try { // for error handling
Aast tmp173_AST = null;
tmp173_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp173_AST);
match(KW_STREAM);
malformed_symbol();
stream_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
sym.addStream(stream_AST.getText(), STREAM);
def_stream_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_stream_stmt_AST;
}
/**
* Matches a <code>DEFINE TEMP-TABLE or DEFINE WORK-TABLE</code> Progress 4GL
* language statement (note that <code>WORKFILE</code> is a synonym for
* <code>WORK-TABLE</code> and is handled as such. This is the statement that
* defines or imports new user-named temp-tables and work-tables for a
* procedure (internal or external).
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* variables, temp-tables and streams. This rule supports shared, global
* shared or local variables and the syntax for both declaring or defining
* (<code>NEW</code> keyword) shared variables. HOWEVER, all the matching
* for these optional keywords is done in the <code>define_stmt</code> rule.
* This refactoring allows all <code>DEFINE</code> statements to be supported
* without ambiguity.
* <p>
* This rule matches the <code>TEMP-TABLE, WORK-TABLE or WORKFILE</code>
* keywords and then calls other rules to implement the different
* alternatives.
* <p>
* Since field name references within this statement can be unambiguous
* even when they are ambiguous outside of this statement, a schema scope
* is added and removed at the beginning and end of this rule. Then anytime
* fields are added to the table, the definition in this scope is refreshed
* which makes the latest definition available to subsequent matching in
* this rule.
* <p>
* Calls the following:
* <p>
* <ul>
* <li> {@link #symbol}
* <li> {@link #like_clause}
* <li> {@link #add_temp_table_field}
* <li> {@link #index_clause}
* </ul>
*
* @param tt_new
* <code>true</code> if this is a new shared or new global shared temp-table.
* @param tt_global
* <code>true</code> if this is a global shared temp-table.
* @param tt_shared
* <code>true</code> if this is a shared temp-table.
* @param am
* Access modifiers if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
* @param st
* Static specifier if not null. Only will be non-null if this is a resource defined
* as a member of a class definition.
*/
public final String def_temp_table_stmt(
boolean tt_new, boolean tt_global, boolean tt_shared, Aast am, Aast st
) throws RecognitionException, TokenStreamException {
String tablename = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_temp_table_stmt_AST = null;
Token tt = null;
Aast tt_AST = null;
Token wt = null;
Aast wt_AST = null;
Aast t_AST = null;
Token ku = null;
Aast ku_AST = null;
Token kr = null;
Aast kr_AST = null;
Aast bt_AST = null;
try { // for error handling
NameNode table = null;
int tabType = TEMP_TABLE;
String b4table = null;
sym.addSchemaScope(false);
{
{
switch ( LA(1)) {
case KW_TEMP_TAB:
{
tt = LT(1);
tt_AST = (Aast)astFactory.create(tt);
astFactory.makeASTRoot(currentAST, tt_AST);
match(KW_TEMP_TAB);
break;
}
case KW_WORK_TAB:
{
wt = LT(1);
wt_AST = (Aast)astFactory.create(wt);
astFactory.makeASTRoot(currentAST, wt_AST);
match(KW_WORK_TAB);
tabType = WORK_TABLE;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
symbol();
t_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
Aast node = (tt_AST == null) ? wt_AST : tt_AST;
if (tt_shared)
{
node.putAnnotation("tt_shared", true);
if (tt_global)
{
node.putAnnotation("tt_global", true);
}
if (tt_new)
{
node.putAnnotation("tt_new", true);
}
}
// always add temp-tables/work-tables into the global scope
table = sym.addTable(t_AST.getText(), tabType, true, node, am, st);
{
_loop1420:
do {
if ((LA(1)==KW_NO_UNDO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ku = LT(1);
ku_AST = (Aast)astFactory.create(ku);
astFactory.addASTChild(currentAST, ku_AST);
match(KW_NO_UNDO);
sym.setTableOption(table, KW_NO_UNDO, ku_AST);
}
else if ((LA(1)==KW_UNDO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp174_AST = null;
tmp174_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp174_AST);
match(KW_UNDO);
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RCOD_INF) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
kr = LT(1);
kr_AST = (Aast)astFactory.create(kr);
astFactory.addASTChild(currentAST, kr_AST);
match(KW_RCOD_INF);
sym.setTableOption(table, KW_RCOD_INF, kr_AST);
}
else if ((LA(1)==KW_REF_ONLY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp175_AST = null;
tmp175_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp175_AST);
match(KW_REF_ONLY);
}
else if ((LA(1)==KW_XML_NNAM) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
xml_node_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SERIALZN) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NAMESP_P||LA(1)==KW_NAMESP_U) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
namespace_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_B4_TABLE) && (_tokenSet_15.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
b4table=before_table_clause();
bt_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LIKE||LA(1)==KW_LIKE_SEQ) && (_tokenSet_49.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
like_clause(t_AST.getText(), table, true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2))) && (_tokenSet_52.member(LA(3)))) {
add_temp_table_field(table);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_INDEX) && (_tokenSet_53.member(LA(2))) && (_tokenSet_54.member(LA(3))))&&( tabType == TEMP_TABLE )) {
index_clause(table);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1420;
}
} while (true);
}
}
def_temp_table_stmt_AST = (Aast)currentAST.root;
sym.finalizeTableDefine(table, def_temp_table_stmt_AST);
sym.deleteSchemaScope(false);
tablename = t_AST.getText();
// handle the before-table definition which was deferred because it must only be done
// after the main table is fully defined (otherwise the fields, indexes and so forth
// may not be present)
if (b4table != null)
{
NameNode before = sym.addTable(b4table, TEMP_TABLE, true, bt_AST, null, null);
before.getAst().putAnnotation("after-table", table.getName());
table.getAst().putAnnotation("before-table", b4table);
Aast[] fields = sym.addFieldsFrom(before, tablename);
for (int i = 0; i < fields.length; i++)
{
Aast mandAst = fields[i].getImmediateChild(KW_MAND, null);
if (mandAst != null)
{
mandAst.remove();
}
sym.processLikeField(fields[i], false, tablename + "." + fields[i].getText());
}
// add the 'rowState' index on the '__row-state__' field
Aast idxAst = (Aast)astFactory.make( (new ASTArray(1)).add((Aast)astFactory.create(INDEX,"rowState")));
Aast idxFieldAst = (Aast)astFactory.make( (new ASTArray(1)).add((Aast)astFactory.create(INDEX_FIELD,"__row-state__")));
idxAst.graft(idxFieldAst);
before.getAst().graft(idxAst);
if (ku_AST != null)
{
sym.setTableOption(before, KW_NO_UNDO, ku_AST);
}
sym.finalizeTableDefine(before, null);
}
def_temp_table_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_temp_table_stmt_AST;
return tablename;
}
/**
* Matches a <code>DEFINE VARIABLE</code> Progress 4GL language statement.
* This is the statement that defines or imports new user-named variables.
* The {@link #symbol} rule is used to force the token type for the variable
* name to be a <code>SYMBOL</code>. Then this name is passed as a parameter
* to the {@link #as_clause} or {@link #like_clause} rules, which add this
* variable to the variable dictionary associating it with the correct data
* type.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* variables, temp-tables and streams. This rule supports shared, global
* shared or local variables and the syntax for both declaring or defining
* (<code>NEW</code> keyword) shared variables. HOWEVER, all the matching
* for these optional keywords is done in the <code>define_stmt</code> rule.
* This refactoring allows all <code>DEFINE</code> statements to be supported
* without ambiguity.
* <p>
* Multiple options are supported in any order (which is how Progress handles
* these), however this code does not check for a repeated definition of
* the options.
* <p>
* This rule implements all logic needed to define and initialize array
* variables (using the <code>EXTENT</code>, <code>INITIAL [ ,,, ]</code>
* and <code>LABEL string, string...</code> syntax. These option rules are
* all implemented as separate rules to force a clean tree structure for
* each option rather than accepting a flat structure where all options and
* any associated data are all created as siblings. Instead, each option
* subtree is created under its associated keyword's token and this is a
* child of the <code>DEFINE</code> keyword.
*
* @param allowColon
* Set to <code>true</code> on return to tell the calling code to match either
* a DOT or a COLON to end the statement (this will be set only if a triggers
* phrase is matched).
* @param ds
* The definition node for this member.
* @param am
* Access mode node if specified.
* @param st
* Static node if specified.
*
* @return The variable name that is being defined.
*/
public final String def_var_stmt(
boolean[] allowColon, Aast ds, Aast am, Aast st
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_var_stmt_AST = null;
Token va = null;
Aast va_AST = null;
Aast s_AST = null;
Aast res_AST = null;
Aast non_res_AST = null;
Aast a_AST = null;
Aast l_AST = null;
try { // for error handling
boolean view_as_triggered = false;
boolean handle = false;
boolean object = false;
int ftype = -1;
int size = 0; // no-extent
boolean had_as_clause = false;
boolean inClass = (sym.getCurrentClassDef() != null);
int initcount = -1;
boolean containsExtent = false;
va = LT(1);
va_AST = (Aast)astFactory.create(va);
match(KW_VAR);
hide(va);
{
if (((_tokenSet_15.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !inClass )) {
symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = s_AST.getText();
}
else if (((_tokenSet_1.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( inClass && !inMethodDef )) {
any_symbol_at_all();
res_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = res_AST.getText();
}
else if (((_tokenSet_53.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( inClass && inMethodDef )) {
any_non_reserved_symbol();
non_res_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = non_res_AST.getText();
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1073:
do {
if ((LA(1)==KW_AS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
as_clause(varname, false);
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ftype = a_AST.getFirstChild().getType();
if (ftype == KW_HANDLE ||
ftype == KW_WID_HAND ||
ftype == KW_COM_HNDL)
{
handle = true;
}
if (ftype == CLASS_NAME)
{
object = true;
}
if (had_as_clause)
{
System.out.println(
String.format("Multiple AS clauses for the [%s] var definition at " +
"line %d column %d",
varname, a_AST.getLine(), a_AST.getColumn()));
}
else
{
had_as_clause = true;
}
}
else if ((LA(1)==KW_LIKE||LA(1)==KW_LIKE_SEQ) && (_tokenSet_49.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
like_clause(varname, null, false);
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ftype = l_AST.getFirstChild().getType();
if (ftype == VAR_HANDLE ||
ftype == VAR_COM_HANDLE ||
ftype == FIELD_HANDLE ||
ftype == FIELD_COM_HANDLE)
{
handle = true;
}
if (ftype == VAR_CLASS ||
ftype == FIELD_CLASS)
{
object = true;
}
}
else if ((LA(1)==KW_EXTENT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
size=extent();
astFactory.addASTChild(currentAST, returnAST);
containsExtent = true;
}
else if ((LA(1)==KW_INIT) && (_tokenSet_55.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
initcount=initializer(ftype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SERIALZN) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_COL_LAB) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
column_label();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DECIMALS) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
decimals_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DROP_TAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp176_AST = null;
tmp176_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp176_AST);
match(KW_DROP_TAR);
}
else if ((LA(1)==KW_CASE_SEN||LA(1)==KW_NOT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
case_sensitive();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_UNDO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp177_AST = null;
tmp177_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp177_AST);
match(KW_NO_UNDO);
}
else if ((LA(1)==KW_VIEW_AS) && (_tokenSet_56.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
view_as_phrase(varname);
astFactory.addASTChild(currentAST, returnAST);
view_as_triggered = true;
}
else if ((LA(1)==KW_TRIGGERS) && (LA(2)==DOT||LA(2)==COLON) && (LA(3)==KW_END||LA(3)==KW_ON)) {
trigger_phrase();
astFactory.addASTChild(currentAST, returnAST);
allowColon[0] = true;
}
else {
break _loop1073;
}
} while (true);
}
// Handle the situation where there may have been an initializer but no explicit extent
// initcount != -1 and size == -1 would be indicative of this.
if (containsExtent)
{
size = (size == -1 && initcount != -1) ? initcount : size;
}
// if no explicit override occurred AND if the type is not a handle AND not an object
// add a fill-in widget to the widget namespace, with the same name (handle,
// com-handle and object lvalues cannot be frame fields)
// TODO: do we need to do this with RAW, MEMPTR types too?
if (view_as_triggered == false && !handle && !object)
{
sym.addWidget(varname, WID_FILL_IN);
}
processMember(varname, DEFINE_VARIABLE, ds, (a_AST != null) ? a_AST : l_AST, am, st, null, null, size);
def_var_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_var_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE PARAMETER</code> Progress 4GL language statement.
* This is the statement that defines or imports new user-named parameters
* for a procedure (internal or external).
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* variables, temp-tables and streams. This rule supports shared, global
* shared or local variables and the syntax for both declaring or defining
* (<code>NEW</code> keyword) shared variables. HOWEVER, all the matching
* for these optional keywords is done in the <code>define_stmt</code> rule.
* This refactoring allows all <code>DEFINE</code> statements to be supported
* without ambiguity.
* <p>
* This rule matches the <code>PARAMETER</code> keyword and then calls
* other rules to implement the different alternatives.
* <p>
* Calls {@link #regular_parm}, {@link #table_parm} and {@link #def_buf_stmt}.
*
* @return The variable name of the variable that was defined or
* <code>null</code> if this is a record or buffer reference
* instead.
*/
public final String def_parm_stmt() throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_parm_stmt_AST = null;
Token p = null;
Aast p_AST = null;
try { // for error handling
p = LT(1);
p_AST = (Aast)astFactory.create(p);
match(KW_PARM);
hide(p);
{
if ((_tokenSet_57.member(LA(1))) && (_tokenSet_58.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
varname=table_parm();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_BUFFER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
def_buf_stmt(false, false, false, null, null);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
varname=regular_parm(p_AST, null);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
def_parm_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_parm_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE PROPERTY</code> Progress 4GL language statement. This is the statement that
* defines new user-named properties for the currently active class definition.
* <p>
* The {@link #any_symbol_at_all} rule is used to force the token type for the property name to be a
* <code>SYMBOL</code>. That means property names can be reserved keywords. Then this name is passed as a
* parameter to the {@link #as_clause} rule, which adds this property to the dictionary for the class
* definition, associating it with the correct data type.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching on the <code>DEFINE</code>
* keyword and the optional shared scope for variables, temp-tables and streams. This rule supports an
* optional {@link #access_mode}. HOWEVER, all the matching for these optional keywords is done in the
* <code>define_stmt</code> rule. This refactoring allows all <code>DEFINE</code> statements to be supported
* without ambiguity.
* <p>
* Multiple options are supported in any order (which is how Progress handles these), however this code
* does not check for a repeated definition of the options.
* <p>
* The option sub-rules are all implemented as separate rules to force a clean tree structure for each
* option rather than accepting a flat structure where all options and any associated data are all created
* as siblings. Instead, each option subtree is created under its associated keyword's token and this is
* a child of the <code>DEFINE</code> keyword.
* <p>
* An undocumented quirk in the 4GL is that there can be more than one getter or more than one setter.
*
* @param ds
* The definition node for this member.
* @param am
* Access mode node if specified.
* @param st
* Static node if specified.
* @param ov
* Override node if specified.
* @param ab
* Abstract node if specified.
*
* @return The property name being defined.
*/
public final String def_prop_stmt(
Aast ds, Aast am, Aast st, Aast ov, Aast ab
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_prop_stmt_AST = null;
Token pr = null;
Aast pr_AST = null;
Aast s_AST = null;
Aast a_AST = null;
Aast gs1_AST = null;
Aast gs2_AST = null;
try { // for error handling
int ftype = -1;
int size = 0; // no-extent
int initcount = -1;
boolean containsExtent = false;
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PROPERTY);
hide(pr);
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = s_AST.getText();
{
_loop1076:
do {
switch ( LA(1)) {
case KW_AS:
{
as_clause(varname, false);
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ftype = a_AST.getFirstChild().getType();
break;
}
case KW_EXTENT:
{
size=extent();
astFactory.addASTChild(currentAST, returnAST);
containsExtent = true;
break;
}
case KW_INIT:
{
initcount=initializer(ftype);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SERIALZN:
{
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_UNDO:
{
Aast tmp178_AST = null;
tmp178_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp178_AST);
match(KW_NO_UNDO);
break;
}
default:
{
break _loop1076;
}
}
} while (true);
}
// Handle the situation where there may have been an initializer but no explicit extent
// initcount != -1 and size == -1 would be indicative of this.
if (containsExtent)
{
size = (size == -1 && initcount != -1) ? initcount : size;
}
// this MUST be done before the getter_setter because references to the property
// inside those blocks will otherwise be missing some property-specific annotations
processMember(varname, DEFINE_PROPERTY, ds, a_AST, am, st, ov, ab, size);
boolean getter = false;
boolean setter = false;
getter_setter();
gs1_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
getter = getter || gs1_AST.getType() == KW_GET;
setter = setter || gs1_AST.getType() == KW_SET;
{
_loop1078:
do {
if ((LA(1)==DOT) && (_tokenSet_59.member(LA(2))) && (_tokenSet_60.member(LA(3)))) {
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
getter_setter();
gs2_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
getter = getter || gs2_AST.getType() == KW_GET;
setter = setter || gs2_AST.getType() == KW_SET;
}
else {
break _loop1078;
}
} while (true);
}
sym.postProcessProperty(varname, getter, setter);
def_prop_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = def_prop_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE EVENT</code> Progress 4GL language statement.
* This is the statement that defines new user-named events for the
* currently active class definition.
* <p>
* The {@link #any_symbol_at_all} rule is used to force the token type for the
* event name to be a <code>SYMBOL</code>. Then this name is passed added
* to the dictionary for the class definition, associating it with the correct
* data type.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* variables, temp-tables and streams. This rule supports an optional
* {@link #access_mode}. HOWEVER, all the matching for these optional
* keywords is done in the <code>define_stmt</code> rule. This refactoring
* allows all <code>DEFINE</code> statements to be supported without
* ambiguity.
* <p>
* Multiple options are supported in any order (which is how Progress handles
* these), however this code does not check for a repeated definition of
* the options.
* <p>
* The option sub-rules are all implemented as separate rules to force a
* clean tree structure for each option rather than accepting a flat
* structure where all options and any associated data are all created as
* siblings. Instead, each option subtree is created under its associated
* keyword's token and this is a child of the <code>DEFINE</code> keyword.
*
* @param ds
* The definition node for this member.
* @param am
* Access mode node if specified.
* @param st
* Static node if specified.
* @param ov
* Override node if specified.
* @param ab
* Abstract node if specified.
*
* @return The event name being defined.
*/
public final String def_event_stmt(
Aast ds, Aast am, Aast st, Aast ov, Aast ab
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_event_stmt_AST = null;
Token ev = null;
Aast ev_AST = null;
Aast s_AST = null;
Aast es_AST = null;
try { // for error handling
ev = LT(1);
ev_AST = (Aast)astFactory.create(ev);
match(KW_EVENTS);
hide(ev);
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = s_AST.getText();
// here is where we enable the variable lookup for all subsequent
// code in this scope, note that Progress only seems to ever have
// 2 levels of scope: the external proc and any internal proc/
// trigger defs, since you can only define shared or global shared
// vars in the external proc scope, we should *not* need to
// explicitly add vars to the global scope since adding to the
// current scope should be equivalent
sym.addLocalVariable(varname, CLASS_EVENT, null);
sym.addScope();
{
if ((LA(1)==KW_SIGNATUR||LA(1)==KW_VOID) && (LA(2)==KW_VOID||LA(2)==LPARENS) && (_tokenSet_61.member(LA(3)))) {
event_signature();
es_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
dotnet_delegate();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sym.deleteScope();
processMember(varname, DEFINE_EVENT, ds, es_AST, am, st, ov, ab, 0);
def_event_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_event_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE BUTTON</code> Progress 4GL language statement.
* This is the statement that defines user-named button widgets.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword.
* <p>
* This rule matches the <code>BUTTON</code> keyword and all subsequent
* processing. Calls the following rules:
* <p>
* {@link #symbol}
* {@link #ui_stuff}
* {@link #image_stuff}
* {@link #label}
* {@link #like_widget_clause}
* {@link #size_phrase}
* {@link #no_focus_clause}
* {@link #tooltip_clause}
* {@link #trigger_phrase}
* <p>
* All options can be processed in any order.
* <p>
* This supports the undocumented <code>MARGIN-EXTRA</code> option.
* <p>
* This rule updates the widget namespace with the new button widget however
* there is no backing variable for this widget.
*
* @param allowColon
* Set to <code>true</code> on return to tell the calling code to match either
* a DOT or a COLON to end the statement (this will be set only if a triggers
* phrase is matched).
*
* @return The variable name of the button that was defined.
*/
public final String def_button_stmt(
boolean[] allowColon
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_button_stmt_AST = null;
Token but = null;
Aast but_AST = null;
Aast b_AST = null;
try { // for error handling
{
but = LT(1);
but_AST = (Aast)astFactory.create(but);
match(KW_BUTTON);
hide(but);
symbol();
b_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop272:
do {
if ((LA(1)==KW_AUTO_END||LA(1)==KW_AUTO_GO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_AUTO_GO:
{
Aast tmp179_AST = null;
tmp179_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp179_AST);
match(KW_AUTO_GO);
break;
}
case KW_AUTO_END:
{
Aast tmp180_AST = null;
tmp180_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp180_AST);
match(KW_AUTO_END);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_DEFAULT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp181_AST = null;
tmp181_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp181_AST);
match(KW_DEFAULT);
}
else if ((LA(1)==KW_DROP_TAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp182_AST = null;
tmp182_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp182_AST);
match(KW_DROP_TAR);
}
else if ((LA(1)==KW_MARG_EX) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp183_AST = null;
tmp183_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp183_AST);
match(KW_MARG_EX);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_62.member(LA(1))) && (_tokenSet_63.member(LA(2))) && (_tokenSet_24.member(LA(3)))) {
image_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LIKE) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
like_widget_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_FOCUS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
no_focus_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_CV_3D) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp184_AST = null;
tmp184_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp184_AST);
match(KW_NO_CV_3D);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TRIGGERS) && (LA(2)==DOT||LA(2)==COLON) && (LA(3)==KW_END||LA(3)==KW_ON)) {
trigger_phrase();
astFactory.addASTChild(currentAST, returnAST);
allowColon[0] = true;
}
else {
break _loop272;
}
} while (true);
}
}
varname = b_AST.getText();
sym.addWidget(varname, WID_BUTTON);
def_button_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_button_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE RECTANGLE</code> Progress 4GL language statement.
* This is the statement that defines user-named rectangle widgets.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword.
* <p>
* This rule matches the <code>RECTANGLE</code> keyword and all subsequent
* processing. Calls the following rules:
* <p>
* {@link #symbol}
* {@link #edge_clause}
* {@link #ui_stuff}
* {@link #like_widget_clause}
* {@link #size_phrase}
* {@link #tooltip_clause}
* {@link #trigger_phrase}
* <p>
* All options can be processed in any order.
* <p>
* This rule updates the widget namespace with the new rectangle widget
* however there is no backing variable for this widget.
*
* @param allowColon
* Set to <code>true</code> on return to tell the calling code to match either
* a DOT or a COLON to end the statement (this will be set only if a triggers
* phrase is matched).
*
* @return The rectangle name that is being defined.
*/
public final String def_rect_stmt(
boolean[] allowColon
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_rect_stmt_AST = null;
Token re = null;
Aast re_AST = null;
Aast r_AST = null;
try { // for error handling
re = LT(1);
re_AST = (Aast)astFactory.create(re);
match(KW_RECT);
hide(re);
symbol();
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop275:
do {
if ((LA(1)==KW_NO_FILL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp185_AST = null;
tmp185_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp185_AST);
match(KW_NO_FILL);
}
else if ((LA(1)==KW_GRAPHIC) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp186_AST = null;
tmp186_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp186_AST);
match(KW_GRAPHIC);
}
else if ((LA(1)==KW_ROUNDED) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp187_AST = null;
tmp187_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp187_AST);
match(KW_ROUNDED);
}
else if ((LA(1)==KW_GROUP_BX) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp188_AST = null;
tmp188_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp188_AST);
match(KW_GROUP_BX);
}
else if ((LA(1)==KW_EDGE_C||LA(1)==KW_EDGE_P) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
edge_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LIKE) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
like_widget_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TRIGGERS) && (LA(2)==DOT||LA(2)==COLON) && (LA(3)==KW_END||LA(3)==KW_ON)) {
trigger_phrase();
astFactory.addASTChild(currentAST, returnAST);
allowColon[0] = true;
}
else {
break _loop275;
}
} while (true);
}
varname = r_AST.getText();
sym.addWidget(r_AST.getText(), WID_RECT);
def_rect_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_rect_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE IMAGE</code> Progress 4GL language statement.
* This is the statement that defines user-named image widgets.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword.
* <p>
* This rule matches the <code>IMAGE</code> keyword and all subsequent
* processing. Calls the following rules:
* <p>
* {@link #symbol}
* {@link #ui_stuff}
* {@link #stretch_to_fit_clause}
* {@link #image_phrase}
* {@link #like_widget_clause}
* {@link #size_phrase}
* {@link #tooltip_clause}
* <p>
* All options can be processed in any order. In addition to these rules,
* the <code>CONVERT-3D-COLORS</code> and <code>TRANSPARENT</code> options
* can be specified.
* <p>
* This rule updates the widget namespace with the new image widget however
* there is no backing variable for this widget.
*
* @return The variable name of the browse that was defined.
*/
public final String def_image_stmt() throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_image_stmt_AST = null;
Token im = null;
Aast im_AST = null;
Aast i_AST = null;
try { // for error handling
im = LT(1);
im_AST = (Aast)astFactory.create(im);
match(KW_IMAGE);
hide(im);
symbol();
i_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop278:
do {
if ((LA(1)==KW_CVT_3D_C) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp189_AST = null;
tmp189_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp189_AST);
match(KW_CVT_3D_C);
}
else if ((LA(1)==KW_TRANSPAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp190_AST = null;
tmp190_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp190_AST);
match(KW_TRANSPAR);
}
else if ((LA(1)==KW_ST_2_FIT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
stretch_to_fit_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_63.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
image_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LIKE) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
like_widget_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop278;
}
} while (true);
}
varname = i_AST.getText();
sym.addWidget(varname, WID_IMAGE);
def_image_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_image_stmt_AST;
return varname;
}
/**
* Matches a <code>DEFINE PROPERTY</code> Progress 4GL language statement.
* This is the statement that defines new user-named properties for the
* currently active class definition.
* <p>
* The {@link #any_symbol_at_all} rule is used to force the token type for the
* property name to be a <code>SYMBOL</code>. That means property names can
* be reserved keywords. Then this name is passed as a parameter
* to the {@link #as_clause} rule, which adds this property to the dictionary
* for the class definition, associating it with the correct data type.
* <p>
* This rule is called by {@link #define_stmt} which is where the matching
* on the <code>DEFINE</code> keyword and the optional shared scope for
* variables, temp-tables and streams. This rule supports an optional
* {@link #access_mode}. HOWEVER, all the matching for these optional
* keywords is done in the <code>define_stmt</code> rule. This refactoring
* allows all <code>DEFINE</code> statements to be supported without
* ambiguity.
* <p>
* Multiple options are supported in any order (which is how Progress handles
* these), however this code does not check for a repeated definition of
* the options.
* <p>
* The option sub-rules are all implemented as separate rules to force a
* clean tree structure for each option rather than accepting a flat
* structure where all options and any associated data are all created as
* siblings. Instead, each option subtree is created under its associated
* keyword's token and this is a child of the <code>DEFINE</code> keyword.
* <p>
* This is the same as <code>def_prop_stmt</code> except there is no support for getters and
* setters.
*
* @param ds
* The definition node for this member.
* @param am
* Access mode node if specified.
* @param st
* Static node if specified.
* @param ov
* Override node if specified.
* @param ab
* Abstract node if specified.
*
* @return The property name being defined.
*/
public final String def_prop_stmt_pre_scan(
Aast ds, Aast am, Aast st, Aast ov, Aast ab
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast def_prop_stmt_pre_scan_AST = null;
Token pr = null;
Aast pr_AST = null;
Aast s_AST = null;
Aast a_AST = null;
try { // for error handling
int ftype = -1;
int size = 0; // no-extent
int initcount = -1;
boolean containsExtent = false;
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PROPERTY);
hide(pr);
any_symbol_at_all();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = s_AST.getText();
{
_loop1081:
do {
if ((LA(1)==KW_AS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
as_clause(varname, false);
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ftype = a_AST.getFirstChild().getType();
}
else if ((LA(1)==KW_EXTENT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
size=extent();
astFactory.addASTChild(currentAST, returnAST);
containsExtent = true;
}
else if ((LA(1)==KW_INIT) && (_tokenSet_55.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
initcount=initializer(ftype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SERIALZN) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_UNDO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp191_AST = null;
tmp191_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp191_AST);
match(KW_NO_UNDO);
}
else {
break _loop1081;
}
} while (true);
}
// Handle the situation where there may have been an initializer but no explicit extent
// initcount != -1 and size == -1 would be indicative of this.
if (containsExtent)
{
size = (size == -1 && initcount != -1) ? initcount : size;
}
processMember(varname, DEFINE_PROPERTY, ds, a_AST, am, st, ov, ab, size);
def_prop_stmt_pre_scan_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = def_prop_stmt_pre_scan_AST;
return varname;
}
/**
* Implements the <code>TABLE</code>, <code>DATASET</code>, <code>TABLE-HANDLE</code> and
* <code>DATASET-HANDLE</code> logic for parameter definitions (see {@link #def_parm_stmt}).
* <p>
* One would expect that this method has a major namespace update role, since normal parameter
* processing requires this. In fact, only the form which references a table handle or dataset
* handle updates the namespace (the variable namespace in this case). In this case the
* {@link #symbol} rule is called and the resulting name is added as a variable of type
* <code>VAR_HANDLE</code>.
* <p>
* All forms (no matter the caller) that reference a temp-table or dataset name are in fact
* referencing a resource that must have been statically defined previously in the procedure.
* This means that the associated namespace updates have already occurred and this rule simply
* accesses this data via a lookup in the called {@link #record} rule (in the case of a table)
* or directly (in the case of a dataset).
*
* @return The variable name of the handle variable that was defined or
* <code>null</code> if this is a record or dataset name reference.
*/
public final String table_parm() throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast table_parm_AST = null;
Token f = null;
Aast f_AST = null;
Aast t_AST = null;
Aast d_AST = null;
try { // for error handling
boolean handle = false;
boolean dset = false;
NameNode nothing = null;
{
{
switch ( LA(1)) {
case KW_TABLE:
{
Aast tmp192_AST = null;
tmp192_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp192_AST);
match(KW_TABLE);
break;
}
case KW_TAB_HAND:
{
Aast tmp193_AST = null;
tmp193_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp193_AST);
match(KW_TAB_HAND);
handle = true;
break;
}
case KW_DATASET:
{
Aast tmp194_AST = null;
tmp194_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp194_AST);
match(KW_DATASET);
dset = true;
break;
}
case KW_DSET_HND:
{
Aast tmp195_AST = null;
tmp195_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp195_AST);
match(KW_DSET_HND);
handle = true;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_FOR) && (_tokenSet_58.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.addASTChild(currentAST, f_AST);
match(KW_FOR);
}
else if ((_tokenSet_58.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_15.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( handle && f_AST == null )) {
symbol();
t_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = t_AST.getText();
sym.addLocalVariable(varname, VAR_HANDLE, null);
}
else if (((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( handle && f_AST != null )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_15.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( dset )) {
symbol();
d_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// this will be a problem later if it is not found
// TODO: need to check if explicit static/instance qualifiers can be used here
// TODO: need to check implicit static/instance (based on the surrounding code)
d_AST.setType(sym.lookupDataSet(d_AST.getText()));
// CA: for both tables and data-sets, I think this needs to add a new definition,
// hiding the 'FOR src' one; this can be visible if you use the BY-REFERENCE
// option: the handle IDs will be different than as it appears at the 'FOR src';
// until BY-REFERENCE is used, the handle IDs (buffer and temp-table, or dataset)
// for the local parameter and the src are the same; FWD emits the references
// local to the procedure as 'src' references, instead of local references - which
// doesn't look to be correct, when taking BY-REFERENCE into account.
sym.setDatasetOptions(currentClassName,
currentStaticFlag,
d_AST.getText(),
(Aast) d_AST,
d_AST.getType(),
false);
}
else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
nothing=record(false, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop449:
do {
if ((LA(1)==KW_APPEND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp196_AST = null;
tmp196_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp196_AST);
match(KW_APPEND);
}
else if ((LA(1)==KW_BY_VALUE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp197_AST = null;
tmp197_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp197_AST);
match(KW_BY_VALUE);
}
else if ((LA(1)==KW_BIND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp198_AST = null;
tmp198_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp198_AST);
match(KW_BIND);
}
else {
break _loop449;
}
} while (true);
}
}
table_parm_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = table_parm_AST;
return varname;
}
/**
* Implements the core logic for the <code>DEFINE PARAMETER</code> Progress
* 4GL language statement. This is the statement that defines named parameters
* in procedures (external or internal). The {@link #symbol} rule is used to
* force the token type for the variable name to be a <code>SYMBOL</code>.
* Then this name is passed as a parameter to the {@link #as_clause} or
* {@link #like_clause} rules, which add this variable to the variable
* dictionary associating it with the correct data type.
* <p>
* This rule is called by {@link #def_parm_stmt} which is where the matching
* on the <code>PARAMETER</code> keyword is done.
* <p>
* Multiple options are supported in any order (which is how Progress handles
* these), however this code does not check for a repeated definition of
* the options. Note that as an undocumented feature, Progress also allows
* that the AS and LIKE clauses can be provided after other options. This is
* supported. In fact, these clauses can be optional in certain circumstances.
* <p>
* These option rules are all implemented as separate rules to force a clean
* tree structure for each option rather than accepting a flat structure
* where all options and any associated data are all created as siblings.
* Instead, each option subtree is created under its associated keyword's
* token and this is a child of the <code>PARAMETER</code> keyword in the
* calling rule.
*
* @param param
* The parameter AST where to save the extent annotation, if set. May be null.
* @param likeRef
* An <code>Aast</code> of a field/variable to be copyed in a LIKE -like in the event
* that the param does not contain any AS or LIKE clauses.
*
* @return The new variable's name.
*/
public final String regular_parm(
Aast param, Aast likeRef
) throws RecognitionException, TokenStreamException {
String varname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast regular_parm_AST = null;
Aast s_AST = null;
Aast a_AST = null;
Aast l_AST = null;
try { // for error handling
int vtype = -1;
int size = -1;
int initcount = -1;
boolean containsExtent = false;
symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = s_AST.getText();
{
_loop452:
do {
if ((LA(1)==KW_AS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
as_clause(varname, true);
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
vtype = a_AST.getFirstChild().getType();
}
else if ((LA(1)==KW_LIKE||LA(1)==KW_LIKE_SEQ) && (_tokenSet_49.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
like_clause(varname, null, false);
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
vtype = l_AST.getFirstChild().getType();
}
else if ((LA(1)==KW_INIT) && (_tokenSet_55.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
initcount=initializer(vtype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_EXTENT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
size=extent();
astFactory.addASTChild(currentAST, returnAST);
containsExtent = true;
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_COL_LAB) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
column_label();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DECIMALS) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
decimals_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CASE_SEN||LA(1)==KW_NOT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
case_sensitive();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_UNDO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp199_AST = null;
tmp199_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp199_AST);
match(KW_NO_UNDO);
}
else {
break _loop452;
}
} while (true);
}
// Handle the situation where there may have been an initializer but no explicit extent
// initcount != -1 and size == -1 would be indicative of this.
if (containsExtent)
{
size = (size == -1 && initcount != -1) ? initcount : size;
// Move this from the matching of extent, so we could handle the initcount scenario
if ((size == -1 || size > 0) && param != null)
{
param.putAnnotation("extent", Long.valueOf(size));
}
}
if (vtype == -1) // neither as_clause nor like_clause were processed
{
if (likeRef != null)
{
sym.addLocalVariableLike(varname, likeRef);
}
else
{
// throw incomplete parameter definition in regular_parm
}
}
regular_parm_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = regular_parm_AST;
return varname;
}
/**
* Matches the <code>QUERY</code> keyword and the required query name that
* is coded as a {@link #malformed_symbol}.
* <p>
* Used by {@link #def_browse_stmt}, {@link #reposition_stmt} and
* {@link #get_stmt} rules.
* <p>
* This rule naturally duplicates a small subset of what can be matched
* via {@link #lvalue}. This is done to keep usage that is known to be
* hard coded to this subset, unambiguous.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void query_reference() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast query_reference_AST = null;
Aast q_AST = null;
try { // for error handling
{
if ((LA(1)==KW_QUERY) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
Aast tmp200_AST = null;
tmp200_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp200_AST);
match(KW_QUERY);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
malformed_symbol();
q_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
q_AST.setType(QUERY);
// TODO: need to check if explicit static/instance qualifiers can be used here
// TODO: need to check implicit static/instance (based on the surrounding code)
if (sym.lookupQuery(q_AST.getText()) != QUERY)
{
System.out.println(
String.format("Warning: lookup of query '%s' failed at line %d column %d",
q_AST.getText(),
q_AST.getLine(),
q_AST.getColumn()));
}
query_reference_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = query_reference_AST;
}
/**
* Matches the column specification for a <code>DEFINE BROWSE</code>
* language statement which is started by a <code>DISPLAY</code> keyword.
* This is followed by either a record (and optional exclude list of fields)
* or an expression and optional {@link #column_format_phrase} and
* {@link #at_base_field_clause}. This record or expression is documented as
* required but customer source has shown this to actually be optional.
* <p>
* Calls {@link #record_spec} and {@link #browse_enable_phrase} rules.
* <p>
* Note that Progress supports an undocumented use of {@link #space_or_skip}
* as a column specification.
* <p>
* Called by {@link #def_browse_stmt}.
* <p>
* DISPLAY statement doens't pull schema VALEXP or HELP, so this will not use
* {@link #attachAssignSchemaValidation}.
*/
public final void column_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast column_spec_AST = null;
Token bd = null;
Aast bd_AST = null;
Aast r_AST = null;
Aast e_AST = null;
Aast cfp_AST = null;
Aast be_AST = null;
try { // for error handling
Set<String> exceptFields = new HashSet<>();
Set<String> enabledFields = new HashSet<>();
Map<String, Aast> fields2format = new HashMap<>();
boolean hadColumnSpec = false;
bd = LT(1);
bd_AST = (Aast)astFactory.create(bd);
astFactory.makeASTRoot(currentAST, bd_AST);
match(KW_DISP);
{
if (((_tokenSet_13.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!hadColumnSpec &&
(LA(2) == KW_EXCEPT || LA(2) == KW_WITH || LA(2) == KW_ENABLE || LA(2) == DOT) &&
isRecord(LT(1).getText()) &&
!isQualifiedFieldNameQuirk(LT(1), LT(2), LT(3))
)) {
record_spec(null);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_ENABLE && LA(1) != KW_WITH )) {
{
_loop412:
do {
if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
hadColumnSpec = true;
}
else if (((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_ENABLE && LA(1) != KW_WITH )) {
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
column_format_phrase();
cfp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
Aast fieldRef = e_AST;
while (fieldRef.getType() == EXPRESSION)
{
fieldRef = (Aast) fieldRef.getFirstChild();
}
if (fieldRef.getType() > BEGIN_FIELDTYPES &&
fieldRef.getType() < END_FIELDTYPES)
{
fields2format.put((String) fieldRef.getAnnotation("schemaname"), cfp_AST);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
hadColumnSpec = true;
}
else {
break _loop412;
}
} while (true);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_ENABLE) && (_tokenSet_66.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
browse_enable_phrase(enabledFields, exceptFields);
be_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop415:
do {
if ((LA(1)==KW_WITH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
browse_options_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop415;
}
} while (true);
}
column_spec_AST = (Aast)currentAST.root;
// if there is ENABLE phrase, pull the schema valexp; otherwise, omit it, as it will not
// be used.
if (be_AST != null)
{
if (r_AST != null)
{
// if there is ENABLE ALL, nothing else to do; otherwise, add to EXCEPT all fields
// which are not part of ENABLE
if (!be_AST.downPath(KW_ALL))
{
String tableSchemaName = (String) r_AST.getAnnotation("schemaname");
Iterator<Aast> fieldIter = sym.fields(tableSchemaName);
while (fieldIter.hasNext())
{
Aast schemaRef = fieldIter.next();
String fieldSchemaName = tableSchemaName + "." +
schemaRef.getText().toLowerCase();
if (!enabledFields.contains(fieldSchemaName))
{
exceptFields.add(fieldSchemaName);
}
}
}
Aast fp = (Aast)astFactory.create(FRAME_PHRASE,"");
attachAllAssignSchemaValidation(fp, r_AST, sym, exceptFields);
if (fp.getNumImmediateChildren() > 0)
{
column_spec_AST.addChild(fp);
}
}
else
{
Aast child = null;
if (be_AST.downPath(KW_ALL))
{
// walk the DISPLAY fields
child = (Aast) bd_AST.getFirstChild();
}
else
{
// walk the ENABLE fields
child = (Aast) be_AST.getFirstChild();
}
// we have an explicit list of fields, maybe from different tables; we need to
// walk the ENABLE field references explicitly
while (child != null)
{
Aast fieldRef = child;
while (fieldRef.getType() == EXPRESSION)
{
fieldRef = (Aast) fieldRef.getFirstChild();
}
if (fieldRef.getType() > BEGIN_FIELDTYPES &&
fieldRef.getType() < END_FIELDTYPES)
{
String fieldSchemaName = (String) fieldRef.getAnnotation("schemaname");
if (!exceptFields.contains(fieldSchemaName))
{
Aast fp = fields2format.get(fieldSchemaName);
boolean attach = (fp == null);
if (attach)
{
fp = (Aast)astFactory.create(FORMAT_PHRASE);
}
attachAssignSchemaValidation(fp, fieldRef, sym);
if (attach && fp.getNumImmediateChildren() > 0)
{
child.getParent().graftAt(fp, child.getIndexPos() + 1);
}
}
}
child = (Aast) child.getNextSibling();
}
}
}
column_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = column_spec_AST;
}
/**
* Matches the browse options phrase that is almost the same as the frame
* phrase construct (except it is only used in the defining browses). It
* always begins with the <code>WITH</code> keyword. All of its options
* can be specified in any order. Called from {@link #column_spec}.
* <p>
* The following list of rules are called to properly implement the tree
* building:
* <p>
* <ul>
* <li> {@link #ui_stuff}
* <li> {@link #row_height_clause}
* <li> {@link #size_phrase}
* <li> {@link #title_phrase}
* <li> {@link #tooltip_clause}
* <li> {@link #misc_frame_opts}
* <li> {@link #down_clause}
* </ul>
* <p>
* Undocumented options <code>KEEP-TAB-ORDER</code>, <code>CENTERED</code>,
* <code>KW_NO_COLS</code>, <code>KW_SCROLLBL</code>, <code>KW_NO_TAB_S</code> and
* <code>KW_NO_UNDL</code> are supported here since Progress allows them.
* <p>
* The order of the above list is important in the case of the last
* rule reference to {@link #down_clause}. This prefixes an expression
* to a keyword which is inherently ambiguous. The ambiguity is resolved by
* the careful ordering of these alternatives. Based on the complicated
* loop closure rule needed to process these options in any order, the
* k=2 lookahead is often being checked to confirm that a following
* token is seen before a match is made. This logic has been reviewed and
* many cases have been tested, however all possible cases cannot be tested.
* For this reason, one must watch this rule carefully. We have disabled
* ambiguity warnings and it is thought that this is safe, but great care
* must be taken to confirm this over time.
*/
public final void browse_options_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast browse_options_phrase_AST = null;
Token wi = null;
Aast wi_AST = null;
try { // for error handling
Aast tmp201_AST = null;
tmp201_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp201_AST);
match(KW_WITH);
{
_loop435:
do {
if ((LA(1)==KW_WITH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
wi = LT(1);
wi_AST = (Aast)astFactory.create(wi);
match(KW_WITH);
hide(wi);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_MULTIPLE||LA(1)==KW_SINGLE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_MULTIPLE:
{
Aast tmp202_AST = null;
tmp202_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp202_AST);
match(KW_MULTIPLE);
break;
}
case KW_SINGLE:
{
Aast tmp203_AST = null;
tmp203_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp203_AST);
match(KW_SINGLE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_SEPS||LA(1)==KW_SEPS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SEPS:
{
Aast tmp204_AST = null;
tmp204_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp204_AST);
match(KW_SEPS);
break;
}
case KW_NO_SEPS:
{
Aast tmp205_AST = null;
tmp205_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp205_AST);
match(KW_NO_SEPS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_ASSGN) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp206_AST = null;
tmp206_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp206_AST);
match(KW_NO_ASSGN);
}
else if ((LA(1)==KW_NO_ROW_M) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp207_AST = null;
tmp207_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp207_AST);
match(KW_NO_ROW_M);
}
else if ((LA(1)==KW_NO_BOX) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp208_AST = null;
tmp208_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp208_AST);
match(KW_NO_BOX);
}
else if ((LA(1)==KW_NO_LABEL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp209_AST = null;
tmp209_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp209_AST);
match(KW_NO_LABEL);
}
else if ((LA(1)==KW_NO_VALID) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp210_AST = null;
tmp210_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp210_AST);
match(KW_NO_VALID);
}
else if ((LA(1)==KW_NO_AUTOV) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp211_AST = null;
tmp211_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp211_AST);
match(KW_NO_AUTOV);
}
else if ((LA(1)==KW_NO_SCR_V||LA(1)==KW_SCROLL_V) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_NO_SCR_V:
{
Aast tmp212_AST = null;
tmp212_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp212_AST);
match(KW_NO_SCR_V);
break;
}
case KW_SCROLL_V:
{
Aast tmp213_AST = null;
tmp213_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp213_AST);
match(KW_SCROLL_V);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_DROP_TAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp214_AST = null;
tmp214_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp214_AST);
match(KW_DROP_TAR);
}
else if ((LA(1)==KW_OVERLAY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp215_AST = null;
tmp215_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp215_AST);
match(KW_OVERLAY);
}
else if ((LA(1)==KW_EXPANDBL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp216_AST = null;
tmp216_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp216_AST);
match(KW_EXPANDBL);
}
else if ((LA(1)==KW_FIT_LCOL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp217_AST = null;
tmp217_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp217_AST);
match(KW_FIT_LCOL);
}
else if ((LA(1)==KW_NO_EM_SP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp218_AST = null;
tmp218_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp218_AST);
match(KW_NO_EM_SP);
}
else if ((LA(1)==KW_NO_COLS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp219_AST = null;
tmp219_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp219_AST);
match(KW_NO_COLS);
}
else if ((LA(1)==KW_CENTER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp220_AST = null;
tmp220_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp220_AST);
match(KW_CENTER);
}
else if ((LA(1)==KW_KEEP_TAB) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp221_AST = null;
tmp221_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp221_AST);
match(KW_KEEP_TAB);
}
else if ((LA(1)==KW_SCROLLBL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp222_AST = null;
tmp222_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp222_AST);
match(KW_SCROLLBL);
}
else if ((LA(1)==KW_NO_TAB_S) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp223_AST = null;
tmp223_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp223_AST);
match(KW_NO_TAB_S);
}
else if ((LA(1)==KW_NO_UNDL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp224_AST = null;
tmp224_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp224_AST);
match(KW_NO_UNDL);
}
else if ((LA(1)==KW_TOP_ONLY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp225_AST = null;
tmp225_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp225_AST);
match(KW_TOP_ONLY);
}
else if ((LA(1)==KW_3D) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp226_AST = null;
tmp226_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp226_AST);
match(KW_3D);
}
else if ((LA(1)==KW_NO_EH_FL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp227_AST = null;
tmp227_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp227_AST);
match(KW_NO_EH_FL);
}
else if ((LA(1)==KW_NO_EH_SR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp228_AST = null;
tmp228_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp228_AST);
match(KW_NO_EH_SR);
}
else if ((LA(1)==KW_DIS_STRP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp229_AST = null;
tmp229_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp229_AST);
match(KW_DIS_STRP);
}
else if ((LA(1)==KW_DIS_CEDT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp230_AST = null;
tmp230_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp230_AST);
match(KW_DIS_CEDT);
}
else if ((LA(1)==KW_COLOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
color_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_ROW_H_C||LA(1)==KW_ROW_H_P) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
row_height_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TITLE) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
title_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_67.member(LA(1))) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
misc_frame_opts();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
down_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop435;
}
} while (true);
}
browse_options_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = browse_options_phrase_AST;
}
/**
* Matches the manner of specifying a list of records (and optional include or
* exclude list of fields) for certain database related language statements.
* Calls {@link #record} and {@link #field_list} rules.
* <p>
* Called by {@link #def_query_stmt}, {@link #def_dataset_stmt},
* {@link #def_datasrc_stmt} and {@link #do_repeat_stmt} rules.
*
* @param flds
* <code>true</code> if the field list option should be allowed to
* be matched.
* @param force
* <code>true</code> to force promotion even if the record was
* already previously promoted.
* @param strong
* <code>true</code> to identify all records as being associated with a strong buffer
* scope.
*/
public final void for_record_spec(
boolean flds, boolean force, boolean strong
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_record_spec_AST = null;
try { // for error handling
NameNode nothing = null;
if (strong)
{
sym.markStrongScope(true);
}
Aast tmp231_AST = null;
tmp231_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp231_AST);
match(KW_FOR);
nothing=record(true, force, false);
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_EXCEPT||LA(1)==KW_FIELD) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( flds )) {
field_list();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop201:
do {
if ((LA(1)==COMMA) && (_tokenSet_13.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
comma();
astFactory.addASTChild(currentAST, returnAST);
nothing=record(true, force, false);
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_EXCEPT||LA(1)==KW_FIELD) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( flds )) {
field_list();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop201;
}
} while (true);
}
if (strong)
{
sym.markStrongScope(false);
}
for_record_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = for_record_spec_AST;
}
/**
* Matches the <code>CACHE</code> option for the <code>DEFINE QUERY</code>
* language statement.
* <p>
* Called by {@link #def_query_stmt}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void cache_records() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast cache_records_AST = null;
try { // for error handling
Aast tmp232_AST = null;
tmp232_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp232_AST);
match(KW_CACHE);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
cache_records_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = cache_records_AST;
}
/**
* Matches a Progress 4GL record reference that refers to a table in the
* database schema, or to a buffer/temp-table/work-table that was previously
* defined or created in the source file. Any of these references can often
* be substituted for each other in 4GL source.
* <p>
* The matching portion of this rule is defined as a single token that
* matches the union of the set of all possible record types and the set of
* all possible alternatives for symbol names (a reference to the
* {@link #symbol} rule).
* <p>
* Note that if this rule is used as an alternative to a rule that includes a
* leftmost token defined by the <code>symbol</code> rule, there will be an
* ambiguity that is only resolved by lookahead <b>and</b> the proper
* ordering of the rules.
* <p>
* It is required that where this rule is referenced as one alternative that
* conflicts with the definitions of other alternatives, <b>the order of the
* alternatives must be more specific (in terms of matching criteria) to less
* specific</b>.
* <p>
* The inclusion of the <code>symbol</code> rule ensures that all valid
* symbols are considered a record and will be matched by this rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> since this could be anything. What we
* really require is a token that is one of the following:
* <pre>
* TABLE
* BUFFER
* TEMP_TABLE
* WORK_TABLE
* </pre>
* <p>
* The difference between a <code>SYMBOL</code> and a <code>TABLE</code> can
* only be determined by context (the fact that the lookahead code has
* identified a match with a <code>SYMBOL</code> token which is a construct
* that can occur in a <code>record</code> call. Thus <b>if</b> a match is
* found using lookahead (in the rule that calls this one), then it
* <b>must</b> be correct and necessary to convert the <code>SYMBOL</code>
* token type into the correct type. This is done in an init action that is
* processed at the beginning of this rule. In this way, the rest of the rule
* only sees the first token as a valid <code>TABLE</code> and never tries to
* call the <code>symbol</code> rule since calling that rule would actually
* try to match (and consume from the token stream) a <code>SYMBOL</code>
* token type. <b>Specifying a rule reference to obtain its value from a
* lookahead perspective but then changing the token's type such that the
* rule reference never gets called, is the critical trick that enables
* context sensitive symbol names!</b>
* <p>
* The exit action saves the fully qualified schema name that was matched
* in the schema dictionary. This allows downstream processing to access this
* as an annotation named 'schemaname'. In addition, the exit action stores
* the backing construct for this record (this will be the token type TABLE,
* TEMP_TABLE or WORK_TABLE). By definition, this will be the same as the
* token type for every record type except buffers. This annotation is
* called 'recordtype'.
* <p>
* This rule can only be used in cases where it is non-optional OR there is
* no ambiguity (between the set of unreserved keywords referenced herein and
* any following keywords that would be improperly matched by this rule).
* In this case a semantic predicate could be used to isolate the conflicting
* token types and bypass this rule reference in those cases.
* <p>
* All record references in the parser call this rule. This makes it the
* ideal location to implement the promotion of a table into the current
* scope, since when this rule is called the record has been referenced.
* This is done at the end of the init action, when we know that no exception
* is going to be thrown. <b>At this time we ALWAYS promote each table
* no matter the manner in which we are called and without regard to the
* type of reference (strong, weak or free reference). This seems to resolve
* the implicit lookup requirements for nearly all Progress cases. What makes
* this 'trick' work is that the Progress compiler itself refuses to allow
* ambiguous names to be referenced (code with ambiguous name references
* will fail to compile). This means that the 4GL programmer is required
* to resolve ambiguity. Those places that look ambiguous are made
* unambiguous because the table name has been given preference in the name
* lookups (in the P2J terminology, it was 'promoted'). By always promoting
* this code resolves these issues, but it can create one problem that a
* more descriminating promotion policy (which is probably how Progress is
* internally written) would not have: it is possible that there is a very
* obscure case where the existence of additional (unexpected from a Progress
* perspective) promoted tables can make some names ambiguous that otherwise
* would be unambiguous.</b> Full details of this obscure case are in the
* <a href="package-summary.html#too_much_promotion">Design Document</a>.
*
* @param promote
* If <code>true</code>, promote the record's table for future
* name resolution. If <code>false</code>, do not promote the
* table.
* @param force
* If <code>true</code>, forces re-promotion of records that have
* already been promoted. <code>false</code> will promote but only
* if it hasn't ever been promoted. This flag is only honored if
* the <code>promote</code> parameter is <code>true</code>.
* @param noProp
* <code>true</code> to force any promoted nodes to have their
* no propagate flag set. This disables propagation of these
* nodes across the current scope boundary.
*
* @return The record name node that was found.
*/
public final NameNode record(
boolean promote, boolean force, boolean noProp
) throws RecognitionException, TokenStreamException {
NameNode found;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast record_AST = null;
found = null;
try { // for error handling
String tablename = LT(1).getText();
if (LA(1) < BEGIN_RECORDTYPES || LA(1) > END_RECORDTYPES)
{
found = sym.lookupTableNode(tablename, forceTemp, forcePersistent);
int newtype = (found == null) ? -1 : found.getType();
// the preference for temp-table or persistent table failed, now look everywhere.
if (newtype == -1 && (forceTemp || forcePersistent))
{
forceTemp = false;
forcePersistent = false;
found = sym.lookupTableNode(tablename, false, false);
newtype = (found == null) ? -1 : found.getType();
}
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if ( newtype != -1 )
{
LT(1).setType( newtype );
}
else
{
// sym.dumpSchema();
throw new NoViableAltException(LT(1), getFilename());
}
}
// if we have gotten this far, then the tablename is valid so we
// can add this table to the current schema scope using this string
if (promote)
sym.promoteTableName(tablename, force, noProp);
{
switch ( LA(1)) {
case BEGIN_RECORDTYPES:
case TABLE:
case BUFFER:
case TEMP_TABLE:
case WORK_TABLE:
case END_RECORDTYPES:
{
Aast tmp233_AST = null;
tmp233_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp233_AST);
matchRange(BEGIN_RECORDTYPES,END_RECORDTYPES);
break;
}
case DB_SYMBOL:
{
Aast tmp234_AST = null;
tmp234_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp234_AST);
match(DB_SYMBOL);
break;
}
default:
if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
record_AST = (Aast)currentAST.root;
// now store an annotation with the fully qualified name and the
// shorted unabbreviated unique buffer name
TableInfo info = sym.lookupTableInfo(tablename, forceTemp, forcePersistent);
if (info != null)
{
String sig = info.getSignature();
String fullname = info.getQualified();
String bufname = info.getBuffer();
String dbname = info.getDatabase();
int backing = info.getRecordType();
if (sig != null)
record_AST.putAnnotation("db_signature", sig);
if (fullname != null)
record_AST.putAnnotation("schemaname", fullname);
if (bufname != null)
record_AST.putAnnotation("bufname", bufname);
if (dbname != null)
record_AST.putAnnotation("dbname", dbname);
// store the backing construct (this will be the same as the token
// type for every record type except buffers, in which case it will
// be TABLE, TEMP_TABLE or WORK_TABLE)
if (backing != -1)
record_AST.putAnnotation("recordtype", Long.valueOf(backing));
}
record_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = record_AST;
return found;
}
/**
* Matches the <code>FIELDS</code> or <code>EXCEPT</code> keywords and the
* optional following field list which is used to specify the list of fields
* to include or exclude from a particular table. Note that due to the
* natural ambiguity of <code>FIELDS</code> being optionally abbreviated as
* <code>FIELD</code> and the fact that there is a separate <code>FIELD</code>
* keyword used for different purposes, the <code>FIELDS</code> keyword has
* been dropped and only a <code>FIELD</code> keyword will be found.
* <p>
* An undocumented feature is that a {@link #record} can be matched instead of
* the list of {@link #lvalue} instances. This is effectively saying all fields
* of the record which makes this clause useless. But it was found in customer
* code.
* <p>
* Used by {@link #record_phrase} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void field_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast field_list_AST = null;
try { // for error handling
allowSymbolMatch = true;
{
switch ( LA(1)) {
case KW_FIELD:
{
Aast tmp235_AST = null;
tmp235_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp235_AST);
match(KW_FIELD);
break;
}
case KW_EXCEPT:
{
Aast tmp236_AST = null;
tmp236_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp236_AST);
match(KW_EXCEPT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LPARENS) && (_tokenSet_68.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1466:
do {
if ((_tokenSet_64.member(LA(1)))) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1466;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
allowSymbolMatch = false;
field_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = field_list_AST;
}
/**
* Matches a simple <code>FOR</code> and a record name for the
* {@link #def_buf_stmt}.
* <p>
* Calls {@link #record}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*
* @return The name of the first record referenced.
*/
public final String simple_for_record_spec() throws RecognitionException, TokenStreamException {
String rtext = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_for_record_spec_AST = null;
Aast r_AST = null;
try { // for error handling
NameNode nothing = null;
boolean old1 = forceTemp;
boolean old2 = forcePersistent;
forcePersistent = true;
Aast tmp237_AST = null;
tmp237_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp237_AST);
match(KW_FOR);
{
if ((LA(1)==KW_TEMP_TAB) && (_tokenSet_13.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp238_AST = null;
tmp238_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp238_AST);
match(KW_TEMP_TAB);
forceTemp = true; forcePersistent = false;
}
else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
nothing=record(false, false, true);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
forceTemp = old1;
forcePersistent = old2;
rtext = r_AST.getText();
simple_for_record_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = simple_for_record_spec_AST;
return rtext;
}
/**
* Matches the <code>LABEL</code> keyword and the required string literal
* or comma separated list of string literals. The subtree is rooted by the
* <code>KW_LABEL</code> keyword. Note that the commas are dropped from the
* resulting AST to simplify processing.
* <p>
* Used by {@link #def_var_stmt}, {@link #def_parm_stmt} and
* {@link #def_buf_stmt}. Once added in all these locations, there was
* a warning that there was ambiguity in the subrule, but this is a
* bogus warning. This warning has been disabled.
* <p>
* The list syntax is used to create different labels for each element in
* an array.
*/
public final void label(
boolean showLabel
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast label_AST = null;
try { // for error handling
Aast tmp239_AST = null;
tmp239_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp239_AST);
match(KW_LABEL);
label_AST = (Aast)currentAST.root;
if(showLabel == true)
{
label_AST.putAnnotation("show-label", true);
}
Aast tmp240_AST = null;
tmp240_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp240_AST);
match(STRING);
{
_loop1105:
do {
if ((LA(1)==COMMA) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
comma();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp241_AST = null;
tmp241_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp241_AST);
match(STRING);
}
else {
break _loop1105;
}
} while (true);
}
label_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = label_AST;
}
/**
* Matches <code>XML-NODE-NAME</code> and a following <code>STRING</code>. Used by
* {@link #def_temp_table_stmt}.
*/
public final void xml_node_name() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast xml_node_name_AST = null;
try { // for error handling
Aast tmp242_AST = null;
tmp242_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp242_AST);
match(KW_XML_NNAM);
Aast tmp243_AST = null;
tmp243_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp243_AST);
match(STRING);
xml_node_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = xml_node_name_AST;
}
/**
* Matches the <code>SERIALIZE-NAME</code> clause with the following string.
* Used from {@link #def_temp_table_stmt}.
*/
public final void serialize_name() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast serialize_name_AST = null;
try { // for error handling
Aast tmp244_AST = null;
tmp244_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp244_AST);
match(KW_SERIALZN);
Aast tmp245_AST = null;
tmp245_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp245_AST);
match(STRING);
serialize_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = serialize_name_AST;
}
/**
* Matches the <code>NAMESPACE-URI</code> or <code>NAMESPACE-PREFIX</code>
* with a following <code>STRING</code>. Used by {@link #def_dataset_stmt}
* {@link #def_temp_table_stmt} and {@link #def_buf_stmt}.
*/
public final void namespace_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast namespace_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_NAMESP_U:
{
Aast tmp246_AST = null;
tmp246_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp246_AST);
match(KW_NAMESP_U);
break;
}
case KW_NAMESP_P:
{
Aast tmp247_AST = null;
tmp247_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp247_AST);
match(KW_NAMESP_P);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp248_AST = null;
tmp248_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp248_AST);
match(STRING);
namespace_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = namespace_clause_AST;
}
/**
* Matches <code>XML-NODE-TYPE</code> with a following <code>STRING</code>. Used by
* {@link #temp_table_field_options} and {@link #def_dataset_stmt}.
*/
public final void xml_node_type() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast xml_node_type_AST = null;
try { // for error handling
Aast tmp249_AST = null;
tmp249_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp249_AST);
match(KW_XML_NTYP);
Aast tmp250_AST = null;
tmp250_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp250_AST);
match(STRING);
xml_node_type_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = xml_node_type_AST;
}
/**
* Matches a <code>DATA-RELATION</code> clause in a {@link #def_dataset_stmt}.
* There is an optional {@link #symbol} which will be manufactured based on
* the given index number if the relation name is not there. The naming
* scheme is to use <code>Relation</code> and append the index number to the
* end. This name (manufactured or provided) is added to a namespace for
* data relations which can then be de-referenced in use as a handle.
*
* @param idx
* 1-based index number of the data relation in a given dataset
* definition.
*/
public final void data_relation(
int idx
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast data_relation_AST = null;
Token dr = null;
Aast dr_AST = null;
Aast d_AST = null;
Aast f_AST = null;
try { // for error handling
dr = LT(1);
dr_AST = (Aast)astFactory.create(dr);
match(KW_DATA_REL);
{
if ((_tokenSet_15.member(LA(1)))) {
symbol();
d_AST = (Aast)returnAST;
}
else if ((LA(1)==KW_FOR)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
for_data_relation_spec();
f_AST = (Aast)returnAST;
data_relation_AST = (Aast)currentAST.root;
if (d_AST == null)
{
// create an artificial node
d_AST = (Aast)astFactory.create(SYMBOL,String.format("Relation%d",idx));
}
String name = d_AST.getText();
// add to the relation namespace
sym.addDataRelation(name, DATA_RELATION);
// build the tree
data_relation_AST = (Aast)astFactory.make( (new ASTArray(3)).add(dr_AST).add(d_AST).add(f_AST));
currentAST.root = data_relation_AST;
currentAST.child = data_relation_AST!=null &&data_relation_AST.getFirstChild()!=null ?
data_relation_AST.getFirstChild() : data_relation_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = data_relation_AST;
}
/**
* Matches a <code>PARENT-ID-RELATION</code> clause in a {@link #def_dataset_stmt}.
* There is an optional {@link #symbol} which will be manufactured based on
* the given index number if the relation name is not there. The naming
* scheme is to use <code>ParentRelation</code> and append the index number to the
* end. This name (manufactured or provided) is added to a namespace for
* data relations which can then be de-referenced in use as a handle.
*
* @param idx
* 1-based index number of the data relation in a given dataset
* definition.
*/
public final void parent_id_relation(
int idx
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast parent_id_relation_AST = null;
Token dr = null;
Aast dr_AST = null;
Aast d_AST = null;
Aast f_AST = null;
try { // for error handling
dr = LT(1);
dr_AST = (Aast)astFactory.create(dr);
match(KW_PAR_IREL);
{
if ((_tokenSet_15.member(LA(1)))) {
symbol();
d_AST = (Aast)returnAST;
}
else if ((LA(1)==KW_FOR)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
for_parent_relation_spec();
f_AST = (Aast)returnAST;
parent_id_relation_AST = (Aast)currentAST.root;
if (d_AST == null)
{
// create an artificial node
d_AST = (Aast)astFactory.create(SYMBOL,String.format("ParentRelation%d",idx));
}
// TODO: add namespace processing for parent id relations, add whatever lookup is needed
// in lvalue presumeably
// String name = #d.getText();
// add to the relation namespace
/// sym.addParentIdRelation(name, PARENT_ID_RELATION);
// build the tree
parent_id_relation_AST = (Aast)astFactory.make( (new ASTArray(3)).add(dr_AST).add(d_AST).add(f_AST));
currentAST.root = parent_id_relation_AST;
currentAST.child = parent_id_relation_AST!=null &&parent_id_relation_AST.getFirstChild()!=null ?
parent_id_relation_AST.getFirstChild() : parent_id_relation_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = parent_id_relation_AST;
}
/**
* Matches a temp-table buffer for the data-source statement. The name of the buffer
* can optionally be followed by KEYS keyword that defines a unique key for finding a
* record in the temp-table that uses it a data source.
*/
public final void source_buffer_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast source_buffer_phrase_AST = null;
try { // for error handling
NameNode nothing = null;
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_KEYS) && (LA(2)==LPARENS) && (_tokenSet_64.member(LA(3))))&&( LA(1) == KW_KEYS )) {
datasrc_keys_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
source_buffer_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = source_buffer_phrase_AST;
}
/**
* Matches the <code>KEYS</code> clause in a source buffer specification of
* the <code>DEFINE DATA-SOURCE</code> statement. Called directly by
* {@link #source_buffer_phrase}.
*/
public final void datasrc_keys_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast datasrc_keys_clause_AST = null;
try { // for error handling
Aast tmp251_AST = null;
tmp251_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp251_AST);
match(KW_KEYS);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_ROWID) && (LA(2)==RPARENS) && (_tokenSet_3.member(LA(3)))) {
Aast tmp252_AST = null;
tmp252_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp252_AST);
match(KW_ROWID);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
{
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop228:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop228;
}
} while (true);
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
datasrc_keys_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = datasrc_keys_clause_AST;
}
/**
* Matches all Progress 4GL variable, field, stream, buffer or widget names
* that exist in the respective namespaces, including all forms of built-in
* variables such as system handles or 'functions' that take no parameters
* and essentially behave as variables.
* <p>
* The actual lvalue portion of this rule is defined as a single token that
* matches the union of the set of all token types for variables, fields,
* widgets, buffers or <code>SYS_HANDLE or STREAM</code> (this means that
* there is one token type for each possible data type such as
* <code>VAR_INT</code> or <code>FIELD_LOGICAL</code> or
* <code>WID_FILL_IN</code>) and the set of all possible alternatives for
* symbol names (a reference to the {@link #symbol} rule) or the special
* <code>DB_SYMBOL</code>. <code>DB_SYMBOL</code> is the type assigned to
* all partially or fully qualified database schema names. It is created by
* the {@link ProgressLexer#mSYMBOL} method and it may refer to either a
* table (in dbname.tablename format) or a field (in dbname.tablename.field
* format or in tablename.field format). In this rule, we only expect to
* ever be processing a field name (table names are right out).
* <p>
* Due to widget, buffer and query references (especially when attributes
* and methods are used) it is possible to see certain prefixing keywords
* (some reserved and some not) in front of the lvalue itself. In these
* cases, the lvalue will not be found in one of the standard lookup
* processing, but instead the keyword will force the token type to be set
* accordingly (e.g. <code>BUFFER record</code>). The list of such keywords:
* <p>
* <pre>
* BROWSE
* BUFFER
* DATASET
* DATA-SOURCE
* DATA-RELATION
* FRAME
* MENU
* SUB-MENU
* MENU-ITEM
* QUERY
* TEMP-TABLE
* STREAM
* STREAM-HANDLE
* TABLE-HANDLE
* DATASET-HANDLE
* TABLE
* </pre>
* <p>
* It is important to note that a {@link #record} can be matched as a
* BUFFER or TEMP-TABLE.
* <p>
* The operation of this processing is VERY similar if not identical to
* some other rules (see {@link #frame_reference} and
* {@link #query_reference}). Keeping these other rules allows more
* specific usage to be implemented without calling this rule. This can
* reduce ambiguity.
* <p>
* Note that both <code>lvalue</code> and <code>func_call</code> refer to a
* leftmost token that includes the <code>symbol</code> rule. This creates
* an ambiguity that is only resolved by lookahead <b>and</b> the proper
* ordering of the rules (since both are equal alternatives in the
* <code>primary_expr</code> rule).
* <p>
* It is required that where this rule is referenced as one alternative that
* conflicts with the definitions of other alternatives (see
* {@link #primary_expr} and {@link #func_call}), <b>the order of the
* alternatives must be more specific (in terms of matching criteria) to less
* specific</b>. Since the <code>func_call</code> rule contains the very
* specific <code>symbol</code> followed by <code>LPARENS</code> pattern,
* it is more specific than a simple <code>symbol</code> by itself (which is
* one definition of an <code>lvalue</code>. For this reason,
* <code>func_call</code> must always be placed ahead of <code>lvalue</code>
* in alternative lists.
* <p>
* The inclusion of the <code>symbol</code> rule ensures that all valid
* symbols are considered an lvalue and will be matched by this rule. This
* means that the top level expression processing will include a symbol as
* one of the options for its leftmost token, thus "pulling" the
* recursive descent processing down the <code>expr</code> rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> or <code>DB_SYMBOL</code> since this
* could be anything. What we really require is a token that is one of the
* valid variable, field, stream, widget or system handle tokens:
* <pre>
* 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
* CLASS_NAME (static OO 4GL class reference)
* VAR_BYTE
* VAR_DOUBLE
* VAR_FLOAT
* VAR_LONG
* VAR_SHORT
* VAR_USHORT
* STREAM
* 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_HANDLE
* FIELD_LOGICAL
* FIELD_RAW
* FIELD_RECID
* FIELD_ROWID
* WID_BROWSE
* WID_BUTTON
* WID_COMBO
* WID_DIALOG
* WID_EDITOR
* WID_FILL_IN
* WID_FRAME
* 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
* BUFFER
* TABLE
* TEMP_TABLE
* WORK_TABLE
* </pre>
* <p>
* The difference between a <code>SYMBOL</code> (or <code>DB_SYMBOL</code>)
* and a <code>VAR_INT</code> can only be determined by context (the fact
* that the lookahead code has identified a match with a <code>SYMBOL</code>
* or <code>DB_SYMBOL</code> token which is a construct that can occur in an
* lvalue call. Thus <b>if</b> a match is found using lookahead (in the rule
* that calls this one), then it <b>must</b> be correct and necessary to
* convert the <code>SYMBOL</code> or <code>DB_SYMBOL</code> token type into
* the correct variable or field type, using a lookup into the variable and
* field namespaces. This is done in an init action that is processed at
* the beginning of this rule. In this way, the rest of the rule only sees
* the first token as a valid variable or field token type and never tries to
* call the <code>symbol</code> rule since calling that rule would actually
* try to match (and consume from the token stream) a <code>SYMBOL</code>
* token type. <b>Specifying a rule reference to obtain its value from a
* lookahead perspective but then changing the token's type such that the
* rule reference never gets called, is the critical trick that enables
* context sensitive symbol names!</b>
* <p>
* The exit action saves the fully qualified schema name that was matched
* in the schema dictionary. This allows downstream processing to access this
* as an annotation named 'schemaname'. In addition, the exit action stores
* the backing construct for this field (this will be the token type TABLE,
* TEMP_TABLE or WORK_TABLE). This annotation is called 'recordtype'.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* This rule supports an undocumented qualified schema naming quirk in which
* there is whitespace between the record and the .field portion of a schema
* name. In that case Progress matches "record .field" as the single
* qualified field name "record.field". This quirk is matched when a record
* is followed by whitespace, a <code>DOT</code> and a token for which the
* combined text resolves as a field. In that case, the 1st two tokens are
* discarded and their text is concatenated into the 3rd token as if it had
* been tokenized properly originally. The lexer can't solve this problem as
* the syntax is inherently ambiguous with many other constructs. So instead
* we use the knowledge and context of the parser to reassemble the tokens
* when needed. WARNING: this code requires that the parser's lookahead
* depth be at least 3 (k=3). It is interesting to note that no whitespace
* can ever fall between the dot and the field name. It can only occur
* before the dot.
* <p>
* This class has a flag to prefer widgets which allows callers of this rule
* to bias it towards matching widgets in preference to its default policy
* of matching a variable. The vast majority of locations where this rule
* is called do not want a match with a widget and so the default is to match
* variables first.
* <p>
* Built-in variables have a language keyword as the variable name. This
* means that built-ins can support abbreviations. It also means that some
* built-in variables cannot be hidden by a user-defined variable, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in variable is hidden in the namespace by a user-defined variable
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupVariable}.
* <p>
* To ensure this method sees tokens matching the list of variables with
* reserved names, the {@link #reserved_variables} method is included as
* an alternative. This is the same 'pull' trick that is being used for
* generic symbols above. The reason that the generic symbol technique is
* not enough to pull reserved variables is that only unreserved keywords
* are pulled by the <code>symbol</code> method. This can't be changed
* without negative impacts on other code, since <code>symbol</code> is
* used in many locations in the parser. Instead a custom method was
* created to generate pull.
* <p>
* Note that Progress 4GL built-in functions that take no parameters are
* actually implemented in this parser as built-in variables. This
* accurately matches the syntax and semantics of how Progress is implemented
* even if the name itself differs.
* <p>
* This rule also handles all language statements that act like assignable
* variables and/or look like functions that can be assigned. The first
* type are simple enough that they are simply handled as global variables.
* The second kind are handled by the {@link #assign_type_syntax_stmt_list}
* which is called from the main body of this rule.
* <p>
* Since Progress 4GL variable names take precedence (i.e. hide) unqualified
* field names that conflict, the token rewriting code in the method does
* the variable namespace lookup first and if a result is found, this is
* used. This effectively hides the matching field name since the schema
* dictionary is never consulted. If no match is found to a variable name,
* the schema dictionary is used to result the name.
* <p>
* Variables and fields in Progress can be defined as arrays using the
* <code>EXTENT</code> keyword (see {@link #def_var_stmt}). The
* <code>lvalue</code> rule includes an optional postfix reference to the
* rule that implements the subscripting operator [ ]. Only one level of
* subscripting is possible because there is no support for multi-dimensional
* arrays in Progress 4GL. See {@link #subscript} for details.
* <p>
* The use of the <code>subscript</code> rule is detected as ambiguous by
* ANTLR, but this is bogus. Warnings have been disabled for this
* sub-rule.
* <p>
* An immediate following <code>COLON</code> which is not itself followed
* by whitespace, will trigger the matching of Progress methods and
* attributes (see {@link #attribute_or_method} or if the referent (to the
* left of the <code>COLON</code> is a <code>VAR_COM_HANDLE</code>, a
* <code>FIELD_COM_HANDLE</code> or a <code>SYS_HANDLE</code> with an
* <code>oldtype</code> annotation of <code>KW_COM_SELF</code>, then the
* following processing will match COM (Active-X) methods and properties
* via the {@link #com_property_or_method} rule. Progress methods and
* attributes will be rooted at the <code>COLON</code> node and COM methods
* and properties are rooted at that same node except the type will be
* rewritted to be <code>COM_INVOCATION</code>.
* <p>
* An immediate following <code>DB_REF_NON_STATIC</code> token (the
* <code>::</code> "operator" is supported here. This is the syntax added in
* 10.2x which allows a database reference in the form handle::table_name or
* handle::table_name::field_name. These are non-static database names directly
* referenced off a handle using the :: operator.
* <br><strong>Note</strong>At this moment only same-type of chaining can be parsed
* correctly (ie: only <code>:</code> (COLON) or only <code>::</code> DB_REF_NON_STATIC).
* The mixing of both punctuation elements (which is valid in the 4GL) is not supported yet.
* <p>
* Widget references can have an optional qualifier that is matched by the
* {@link #widget_qualifier} rule.
*/
public final void lvalue() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast lvalue_AST = null;
Aast w_AST = null;
Aast ds_AST = null;
Aast strm_AST = null;
Aast fr_AST = null;
try { // for error handling
int oldtype = -1;
String clsName = null;
String origTxt = null;
NameNode nothing = null;
// it is possible to have an optional prefix for widgets, queries and other resources
// this "qualifier" changes the downstream processing
boolean qualifier = false;
boolean builtin = false;
boolean promote = false;
String tablename = null;
int qualType = -1;
switch (LA(1))
{
case KW_FRAME:
// this is a reserved keyword, so we cheat here because we
// know it MUST be followed by a FRAME (we could look this
// up in the frame namespace, but why?)
qualType = WID_FRAME;
break;
case KW_QUERY:
// this is a reserved keyword, so we cheat here because we
// know it MUST be followed by a QUERY
qualType = QUERY;
// TODO: need to check if explicit static/instance qualifiers can be used here
// TODO: need to check implicit static/instance (based on the surrounding code)
if (sym.lookupQuery(LT(2).getText()) != QUERY)
{
CommonToken tok = (CommonToken) LT(2);
System.out.println(
String.format("Warning: lookup of query '%s' failed at line %d column %d",
tok.getText(),
tok.getLine(),
tok.getColumn()));
}
break;
case KW_STREAM:
// this is a reserved keyword, so we cheat here because we
// know it MUST be followed by a STREAM
qualType = STREAM;
break;
case KW_BROWSE:
// not reserved, we have to look it up (it shares a namespace
// with variable but we have split the namespace to allow
// the same symbol to refer to both a WID_ and VAR_ value)
// with browse, we only need to check the widget namespace
qualType = sym.lookupWidget(LT(2).getText());
break;
case KW_MENU:
case KW_SUB_MENU:
// not reserved, we have to look it up (it shares a namespace
// with frame)
qualType = sym.lookupMenu(LT(2).getText());
break;
case KW_MENU_ITM:
// not reserved, we have to look it up
qualType = sym.lookupMenuItem(LT(2).getText());
break;
case KW_TAB_HAND:
case KW_DSET_HND:
case KW_STRM_HND:
// table-handle is not reserved, dataset-handle and stream-handle are reserved
// but we will recursively call ourselves below to match the required following
// handle (field, var...) so just force qualType to be a valid token type and
// that will properly bypass the other init action logic below; this can't just
// lookup vars because it can reference a field
qualType = LA(1);
break;
case KW_BUFFER:
case KW_TABLE:
case KW_TEMP_TAB:
// buffer and temp-table are not reserved, we have to look it
// up in those cases, we'll just do it for table too; this is
// only used as a check to prove that there is a following
// record reference, the actual value is only used to bypass
// the following init action logic below
qualType = sym.lookupTable(LT(2).getText());
// BUFFER b: and TEMP-TABLE tt: promote the name same way as a FIND does.
promote = LA(1) != KW_TABLE; // not for parameters
tablename = LT(2).getText();
break;
case KW_DATASET:
// TODO: need to check if explicit static/instance qualifiers can be used here
// TODO: need to check implicit static/instance (based on the surrounding code)
// it is reserved but we look it up anyway
qualType = sym.lookupDataSet(LT(2).getText());
break;
case KW_DATA_SRC:
// TODO: need to check if explicit static/instance qualifiers can be used here
// TODO: need to check implicit static/instance (based on the surrounding code)
// it is reserved but we look it up anyway
qualType = sym.lookupDataSource(LT(2).getText());
break;
case KW_DATA_REL:
// not reserved, we have to look it up
qualType = sym.lookupDataRelation(LT(2).getText());
break;
}
// if we match one of the optional prefixes AND the next token is
// found in the associated namespace, then we know that we have
// one of the special widget/query qualifier forms --> change all
// downstream processing to handle this!
if (qualType != -1)
{
qualifier = true;
}
else if ((isLstmt(LA(1)) && LA(2) == LPARENS) || LA(1) == KW_DYN_NEW)
{
// nothing to do here, just avoid the else portion of this block
// which would try to rewrite our leftmost token
// these are the assignment-style language statements
}
else if (LA(1) == KW_THIS_OBJ || LA(1) == KW_SUPER)
{
builtin = true;
oldtype = LA(1);
LT(1).setType(VAR_CLASS);
if (oldtype == KW_THIS_OBJ)
{
// special this-object reference
clsName = sym.getCurrentClassName();
}
else
{
// special super object reference
clsName = sym.getCurrentParentName();
}
}
else
{
// this is a normal lvalue!
// this works because the VARTYPES, FIELDTYPES and WIDGETS
// sections are kept in a contiguous "super" block called LVALUE
if (LA(1) < BEGIN_LVALUE || LA(1) > END_LVALUE)
{
String text = LT(1).getText();
// check variables, widgets, class members and fields
int newtype = resolveLvalueCoreType(1, true);
// unqualified field references in a validation may have gotten qualified
if (!text.equals(LT(1).getText()))
{
origTxt = text;
}
// the field name quirk was found and the tokens were merged
if (fieldNameQuirkOriginalText != null)
{
origTxt = fieldNameQuirkOriginalText;
fieldNameQuirkOriginalText = null;
}
// lookup a frame if the field reference wasn't found
// Don't allow frame to be matched if we come from a FORM_ITEM.
if (newtype == -1 && !excludeFrame)
{
// WARNING: this matches with a frame name that does NOT
// have the preceding KW_FRAME qualifying keyword, since
// there is a quirk with frame names (they can start with
// any combination of NUM_LITERAL, MINUS and UNKNOWN_TOKEN
// characters in front of the real symbol and for all other
// frame references we use the malformed_symbol rule to
// re-assemble the parts; this code will not work if
// such a frame name is used here
// this may be a frame name
newtype = sym.lookupFrame(text);
}
// last chance! it may be a stream
if (newtype == -1)
{
// this may be a stream name
newtype = sym.lookupStream(text);
}
// last last chance: it may be a menu/sub-menu reference.
if (newtype == -1)
{
// this may be a menu name
newtype = sym.lookupMenu(text);
}
// at this point, there should always be a match in valid
// Progress 4GL source so we throw an exception if this is
// not the case
if (newtype != -1)
{
oldtype = LA(1);
LT(1).setType(newtype);
}
else
{
// trigger this exception unless we are being processed
// for expression evaluation or are allowed to match a
// symbol, in which case this search is expected to fail
// gracefully
if (!evaluatingExpression && !allowSymbolMatch)
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
{
if (((_tokenSet_69.member(LA(1))) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( qualifier )) {
{
switch ( LA(1)) {
case KW_DATA_SRC:
case KW_QUERY:
case KW_BROWSE:
case KW_DATA_REL:
case KW_MENU:
case KW_MENU_ITM:
case KW_SUB_MENU:
{
{
switch ( LA(1)) {
case KW_QUERY:
{
Aast tmp253_AST = null;
tmp253_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp253_AST);
match(KW_QUERY);
break;
}
case KW_BROWSE:
{
Aast tmp254_AST = null;
tmp254_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp254_AST);
match(KW_BROWSE);
break;
}
case KW_MENU:
{
Aast tmp255_AST = null;
tmp255_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp255_AST);
match(KW_MENU);
break;
}
case KW_SUB_MENU:
{
Aast tmp256_AST = null;
tmp256_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp256_AST);
match(KW_SUB_MENU);
break;
}
case KW_MENU_ITM:
{
Aast tmp257_AST = null;
tmp257_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp257_AST);
match(KW_MENU_ITM);
break;
}
case KW_DATA_SRC:
{
Aast tmp258_AST = null;
tmp258_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp258_AST);
match(KW_DATA_SRC);
break;
}
case KW_DATA_REL:
{
Aast tmp259_AST = null;
tmp259_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp259_AST);
match(KW_DATA_REL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
symbol();
w_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
w_AST.setType(qualType);
break;
}
case KW_DATASET:
{
Aast tmp260_AST = null;
tmp260_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp260_AST);
match(KW_DATASET);
symbol();
ds_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ds_AST.setType(qualType);
break;
}
case KW_STREAM:
{
Aast tmp261_AST = null;
tmp261_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp261_AST);
match(KW_STREAM);
malformed_symbol();
strm_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
strm_AST.setType(qualType);
break;
}
case KW_FRAME:
{
Aast tmp262_AST = null;
tmp262_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp262_AST);
match(KW_FRAME);
malformed_symbol();
fr_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
fr_AST.setType(qualType);
break;
}
case KW_TABLE:
case KW_BUFFER:
case KW_TEMP_TAB:
{
{
switch ( LA(1)) {
case KW_BUFFER:
{
Aast tmp263_AST = null;
tmp263_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp263_AST);
match(KW_BUFFER);
break;
}
case KW_TABLE:
{
Aast tmp264_AST = null;
tmp264_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp264_AST);
match(KW_TABLE);
break;
}
case KW_TEMP_TAB:
{
Aast tmp265_AST = null;
tmp265_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp265_AST);
match(KW_TEMP_TAB);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DSET_HND:
case KW_STRM_HND:
case KW_TAB_HAND:
{
{
switch ( LA(1)) {
case KW_TAB_HAND:
{
Aast tmp266_AST = null;
tmp266_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp266_AST);
match(KW_TAB_HAND);
break;
}
case KW_DSET_HND:
{
Aast tmp267_AST = null;
tmp267_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp267_AST);
match(KW_DSET_HND);
break;
}
case KW_STRM_HND:
{
Aast tmp268_AST = null;
tmp268_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp268_AST);
match(KW_STRM_HND);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lvalue();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
assign_type_syntax_stmt_list();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_71.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case VAR_CHAR:
{
Aast tmp269_AST = null;
tmp269_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp269_AST);
match(VAR_CHAR);
break;
}
case VAR_CLASS:
{
Aast tmp270_AST = null;
tmp270_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp270_AST);
match(VAR_CLASS);
break;
}
case VAR_COM_HANDLE:
{
Aast tmp271_AST = null;
tmp271_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp271_AST);
match(VAR_COM_HANDLE);
break;
}
case VAR_DATE:
{
Aast tmp272_AST = null;
tmp272_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp272_AST);
match(VAR_DATE);
break;
}
case VAR_DATETIME:
{
Aast tmp273_AST = null;
tmp273_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp273_AST);
match(VAR_DATETIME);
break;
}
case VAR_DATETIME_TZ:
{
Aast tmp274_AST = null;
tmp274_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp274_AST);
match(VAR_DATETIME_TZ);
break;
}
case VAR_DEC:
{
Aast tmp275_AST = null;
tmp275_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp275_AST);
match(VAR_DEC);
break;
}
case VAR_HANDLE:
{
Aast tmp276_AST = null;
tmp276_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp276_AST);
match(VAR_HANDLE);
break;
}
case VAR_INT:
{
Aast tmp277_AST = null;
tmp277_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp277_AST);
match(VAR_INT);
break;
}
case VAR_INT64:
{
Aast tmp278_AST = null;
tmp278_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp278_AST);
match(VAR_INT64);
break;
}
case VAR_LOGICAL:
{
Aast tmp279_AST = null;
tmp279_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp279_AST);
match(VAR_LOGICAL);
break;
}
case VAR_LONGCHAR:
{
Aast tmp280_AST = null;
tmp280_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp280_AST);
match(VAR_LONGCHAR);
break;
}
case VAR_MEMPTR:
{
Aast tmp281_AST = null;
tmp281_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp281_AST);
match(VAR_MEMPTR);
break;
}
case VAR_RAW:
{
Aast tmp282_AST = null;
tmp282_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp282_AST);
match(VAR_RAW);
break;
}
case VAR_RECID:
{
Aast tmp283_AST = null;
tmp283_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp283_AST);
match(VAR_RECID);
break;
}
case VAR_ROWID:
{
Aast tmp284_AST = null;
tmp284_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp284_AST);
match(VAR_ROWID);
break;
}
case VAR_POLY:
{
Aast tmp285_AST = null;
tmp285_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp285_AST);
match(VAR_POLY);
break;
}
case VAR_BYTE:
{
Aast tmp286_AST = null;
tmp286_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp286_AST);
match(VAR_BYTE);
break;
}
case VAR_DOUBLE:
{
Aast tmp287_AST = null;
tmp287_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp287_AST);
match(VAR_DOUBLE);
break;
}
case VAR_FLOAT:
{
Aast tmp288_AST = null;
tmp288_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp288_AST);
match(VAR_FLOAT);
break;
}
case VAR_LONG:
{
Aast tmp289_AST = null;
tmp289_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp289_AST);
match(VAR_LONG);
break;
}
case VAR_SHORT:
{
Aast tmp290_AST = null;
tmp290_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp290_AST);
match(VAR_SHORT);
break;
}
case VAR_USHORT:
{
Aast tmp291_AST = null;
tmp291_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp291_AST);
match(VAR_USHORT);
break;
}
case SYS_HANDLE:
{
Aast tmp292_AST = null;
tmp292_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp292_AST);
match(SYS_HANDLE);
break;
}
case STREAM:
{
Aast tmp293_AST = null;
tmp293_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp293_AST);
match(STREAM);
break;
}
case FIELD_BLOB:
{
Aast tmp294_AST = null;
tmp294_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp294_AST);
match(FIELD_BLOB);
break;
}
case FIELD_CHAR:
{
Aast tmp295_AST = null;
tmp295_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp295_AST);
match(FIELD_CHAR);
break;
}
case FIELD_CLASS:
{
Aast tmp296_AST = null;
tmp296_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp296_AST);
match(FIELD_CLASS);
break;
}
case FIELD_CLOB:
{
Aast tmp297_AST = null;
tmp297_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp297_AST);
match(FIELD_CLOB);
break;
}
case FIELD_COM_HANDLE:
{
Aast tmp298_AST = null;
tmp298_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp298_AST);
match(FIELD_COM_HANDLE);
break;
}
case FIELD_DATE:
{
Aast tmp299_AST = null;
tmp299_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp299_AST);
match(FIELD_DATE);
break;
}
case FIELD_DATETIME:
{
Aast tmp300_AST = null;
tmp300_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp300_AST);
match(FIELD_DATETIME);
break;
}
case FIELD_DATETIME_TZ:
{
Aast tmp301_AST = null;
tmp301_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp301_AST);
match(FIELD_DATETIME_TZ);
break;
}
case FIELD_DEC:
{
Aast tmp302_AST = null;
tmp302_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp302_AST);
match(FIELD_DEC);
break;
}
case FIELD_HANDLE:
{
Aast tmp303_AST = null;
tmp303_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp303_AST);
match(FIELD_HANDLE);
break;
}
case FIELD_INT:
{
Aast tmp304_AST = null;
tmp304_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp304_AST);
match(FIELD_INT);
break;
}
case FIELD_INT64:
{
Aast tmp305_AST = null;
tmp305_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp305_AST);
match(FIELD_INT64);
break;
}
case FIELD_LOGICAL:
{
Aast tmp306_AST = null;
tmp306_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp306_AST);
match(FIELD_LOGICAL);
break;
}
case FIELD_RAW:
{
Aast tmp307_AST = null;
tmp307_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp307_AST);
match(FIELD_RAW);
break;
}
case FIELD_RECID:
{
Aast tmp308_AST = null;
tmp308_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp308_AST);
match(FIELD_RECID);
break;
}
case FIELD_ROWID:
{
Aast tmp309_AST = null;
tmp309_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp309_AST);
match(FIELD_ROWID);
break;
}
case WID_BROWSE:
{
Aast tmp310_AST = null;
tmp310_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp310_AST);
match(WID_BROWSE);
break;
}
case WID_BUTTON:
{
Aast tmp311_AST = null;
tmp311_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp311_AST);
match(WID_BUTTON);
break;
}
case WID_COMBO:
{
Aast tmp312_AST = null;
tmp312_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp312_AST);
match(WID_COMBO);
break;
}
case WID_DIALOG:
{
Aast tmp313_AST = null;
tmp313_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp313_AST);
match(WID_DIALOG);
break;
}
case WID_EDITOR:
{
Aast tmp314_AST = null;
tmp314_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp314_AST);
match(WID_EDITOR);
break;
}
case WID_FILL_IN:
{
Aast tmp315_AST = null;
tmp315_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp315_AST);
match(WID_FILL_IN);
break;
}
case WID_FRAME:
{
Aast tmp316_AST = null;
tmp316_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp316_AST);
match(WID_FRAME);
break;
}
case WID_IMAGE:
{
Aast tmp317_AST = null;
tmp317_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp317_AST);
match(WID_IMAGE);
break;
}
case WID_LITERAL:
{
Aast tmp318_AST = null;
tmp318_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp318_AST);
match(WID_LITERAL);
break;
}
case WID_MENU:
{
Aast tmp319_AST = null;
tmp319_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp319_AST);
match(WID_MENU);
break;
}
case WID_MENU_ITM:
{
Aast tmp320_AST = null;
tmp320_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp320_AST);
match(WID_MENU_ITM);
break;
}
case WID_RADIO:
{
Aast tmp321_AST = null;
tmp321_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp321_AST);
match(WID_RADIO);
break;
}
case WID_RECT:
{
Aast tmp322_AST = null;
tmp322_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp322_AST);
match(WID_RECT);
break;
}
case WID_SEL_LST:
{
Aast tmp323_AST = null;
tmp323_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp323_AST);
match(WID_SEL_LST);
break;
}
case WID_SLIDER:
{
Aast tmp324_AST = null;
tmp324_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp324_AST);
match(WID_SLIDER);
break;
}
case WID_SUB_MENU:
{
Aast tmp325_AST = null;
tmp325_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp325_AST);
match(WID_SUB_MENU);
break;
}
case WID_TEXT:
{
Aast tmp326_AST = null;
tmp326_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp326_AST);
match(WID_TEXT);
break;
}
case WID_TOGGLE:
{
Aast tmp327_AST = null;
tmp327_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp327_AST);
match(WID_TOGGLE);
break;
}
case WID_WINDOW:
{
Aast tmp328_AST = null;
tmp328_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp328_AST);
match(WID_WINDOW);
break;
}
case FUNC_CHAR:
{
Aast tmp329_AST = null;
tmp329_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp329_AST);
match(FUNC_CHAR);
break;
}
case FUNC_CLASS:
{
Aast tmp330_AST = null;
tmp330_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp330_AST);
match(FUNC_CLASS);
break;
}
case FUNC_COM_HANDLE:
{
Aast tmp331_AST = null;
tmp331_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp331_AST);
match(FUNC_COM_HANDLE);
break;
}
case FUNC_DATE:
{
Aast tmp332_AST = null;
tmp332_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp332_AST);
match(FUNC_DATE);
break;
}
case FUNC_DATETIME:
{
Aast tmp333_AST = null;
tmp333_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp333_AST);
match(FUNC_DATETIME);
break;
}
case FUNC_DATETIME_TZ:
{
Aast tmp334_AST = null;
tmp334_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp334_AST);
match(FUNC_DATETIME_TZ);
break;
}
case FUNC_DEC:
{
Aast tmp335_AST = null;
tmp335_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp335_AST);
match(FUNC_DEC);
break;
}
case FUNC_HANDLE:
{
Aast tmp336_AST = null;
tmp336_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp336_AST);
match(FUNC_HANDLE);
break;
}
case FUNC_INT:
{
Aast tmp337_AST = null;
tmp337_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp337_AST);
match(FUNC_INT);
break;
}
case FUNC_INT64:
{
Aast tmp338_AST = null;
tmp338_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp338_AST);
match(FUNC_INT64);
break;
}
case FUNC_LOGICAL:
{
Aast tmp339_AST = null;
tmp339_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp339_AST);
match(FUNC_LOGICAL);
break;
}
case FUNC_LONGCHAR:
{
Aast tmp340_AST = null;
tmp340_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp340_AST);
match(FUNC_LONGCHAR);
break;
}
case FUNC_MEMPTR:
{
Aast tmp341_AST = null;
tmp341_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp341_AST);
match(FUNC_MEMPTR);
break;
}
case FUNC_RAW:
{
Aast tmp342_AST = null;
tmp342_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp342_AST);
match(FUNC_RAW);
break;
}
case FUNC_RECID:
{
Aast tmp343_AST = null;
tmp343_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp343_AST);
match(FUNC_RECID);
break;
}
case FUNC_ROWID:
{
Aast tmp344_AST = null;
tmp344_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp344_AST);
match(FUNC_ROWID);
break;
}
case FUNC_POLY:
{
Aast tmp345_AST = null;
tmp345_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp345_AST);
match(FUNC_POLY);
break;
}
case DB_SYMBOL:
{
Aast tmp346_AST = null;
tmp346_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp346_AST);
match(DB_SYMBOL);
break;
}
case KW_U_CTRL:
case KW_U_MSG:
case KW_U_PCTRL:
case KW_U_SERIAL:
case KW_ACT_FORM:
case KW_ACT_WIN:
case KW_AUD_CTRL:
case KW_AUD_POL:
case KW_CLIP:
case KW_CODEBASE:
case KW_COMPILER:
case KW_CUR_LANG:
case KW_CUR_WIN:
case KW_DATASRV:
case KW_DBNAME:
case KW_DEBUGGER:
case KW_DEF_WIN:
case KW_DSL_MGR:
case KW_ERR_STAT:
case KW_ETIME:
case KW_FIL_INFO:
case KW_FOCUS:
case KW_FR_COL:
case KW_FR_DB:
case KW_FR_DOWN:
case KW_FR_FIELD:
case KW_FR_FILE:
case KW_FR_INDEX:
case KW_FR_LINE:
case KW_FR_NAME:
case KW_FR_ROW:
case KW_FR_VAL:
case KW_FWD_DRIV:
case KW_GW:
case KW_GET_CODP:
case KW_GO_PEND:
case KW_IS_ATTR:
case KW_LASTKEY:
case KW_LAST_EVT:
case KW_LINE_CNT:
case KW_LOG_MGR:
case KW_MSG_LINE:
case KW_NOW:
case KW_NUM_ALIA:
case KW_NUM_DBS:
case KW_OPSYS:
case KW_PAGE_NUM:
case KW_PROC_HND:
case KW_PROC_ST:
case KW_PROFILER:
case KW_PROGRESS:
case KW_PROMSGS:
case KW_PROPATH:
case KW_PROVER:
case KW_RCOD_INF:
case KW_RETRY:
case KW_RTOPSYS:
case KW_SCRN_LNS:
case KW_SECUR_P:
case KW_SELF:
case KW_SESSION:
case KW_SUPER:
case KW_TERM:
case KW_THIS_OBJ:
case KW_THIS_PRC:
case KW_TIME:
case KW_TRANS:
case KW_USERID:
{
reserved_variables();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if (((LA(1)==FILENAME))&&( evaluatingExpression || allowSymbolMatch )) {
Aast tmp347_AST = null;
tmp347_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp347_AST);
match(FILENAME);
}
else if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
if (!( evaluatingExpression || allowSymbolMatch ))
throw new SemanticException(" evaluatingExpression || allowSymbolMatch ");
{
if ((LA(1)==DOT) && (_tokenSet_15.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp348_AST = null;
tmp348_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp348_AST);
match(DOT);
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LBRACKET) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
subscript();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==KW_IN) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(2) == KW_FRAME || LA(2) == KW_MENU || LA(2) == KW_SUB_MENU || LA(2) == KW_BROWSE )) {
widget_qualifier();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lvalue_AST = (Aast)currentAST.root;
// assume the AST node to annotate is the root node (we need this
// to be the variable reference itself)
Aast core = lvalue_AST;
int ctype = core.getType();
// browse references will be rooted at a different node
if (ctype == KW_BROWSE)
{
// walk down to get the variable reference as the AST node
core = (Aast) core.getFirstChild();
}
int ftype = core.getType();
String ftext = core.getText();
// after the lvalue has been fully parsed (including subscripts and so forth), it is easy to see the
// next token (before now it was an arbitrary number of tokens away); if the next token is a COLON
// w/o following whitespace AND this is NOT a class lookup, then we would have wanted to parse the
// lvalue with preferWidgets set to true; simulate this now
if (ftype >= BEGIN_VARTYPES &&
ftype <= END_VARTYPES &&
LA(1) == COLON &&
!followedByWhitespace(LT(1)) &&
!sym.isClassLookup())
{
int override = sym.lookupWidget(ftext);
if (override != -1)
{
ftype = override;
core.setType(override);
}
}
// save any original token type that rewriting may have erased
if (oldtype != -1)
{
core.putAnnotation("oldtype", Long.valueOf(oldtype));
}
if (origTxt != null)
{
core.putAnnotation("original-text", origTxt);
}
// fixup deferred qualified class name
// TODO: this doesn't account for all cases (the use of lookupDataMember() above
// does not set this var; this means that these variable references have
// no refid, nor class name and cannot be properly used downstream
if (clsName != null)
sym.annotateClassRef(clsName, core);
// field post-processing
if (ftype > BEGIN_FIELDTYPES && ftype < END_FIELDTYPES)
{
boolean promoted = !inFormStatement && !inLikeClause;
sym.annotateField(core, currentRecord, false, promoted, preferDefaultBuffer);
}
// function post-processing
if (ftype > BEGIN_FUNCTYPES && ftype < END_FUNCTYPES)
{
// write our function-specific annotations
sym.annotateFunction(ftext, core, false);
}
// variable and widget post-processing
if ((ftype > BEGIN_VARTYPES && ftype < END_VARTYPES) ||
(ftype > BEGIN_WIDGETS && ftype < END_WIDGETS))
{
annotateVariable(ftext, ftype, core);
}
// dataset & datasource post-processing
if (ftype == KW_DATASET || ftype == KW_DATA_SRC)
{
sym.setDatasetOptions(currentClassName,
currentStaticFlag,
core.getFirstChild().getText(),
(Aast) core.getFirstChild(),
core.getFirstChild().getType(),
false);
}
if (promote)
{
sym.promoteTableName(tablename, true, false);
}
lvalue_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = lvalue_AST;
}
/**
* Matches a <code>FOR</code> followed by two {@link #record} references
* and options including {@link #field_mapping_clause}. Used by
* {@link #data_relation}.
*/
public final void for_data_relation_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_data_relation_spec_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp349_AST = null;
tmp349_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp349_AST);
match(KW_FOR);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
_loop235:
do {
if ((LA(1)==KW_REPOS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp350_AST = null;
tmp350_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp350_AST);
match(KW_REPOS);
}
else if ((LA(1)==KW_RECURSE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp351_AST = null;
tmp351_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp351_AST);
match(KW_RECURSE);
}
else if ((LA(1)==KW_NOT_ACTV) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp352_AST = null;
tmp352_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp352_AST);
match(KW_NOT_ACTV);
}
else if ((LA(1)==KW_NESTED) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
nested_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_REL_FLDS) && (LA(2)==LPARENS) && (_tokenSet_64.member(LA(3)))) {
field_mapping_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop235;
}
} while (true);
}
for_data_relation_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = for_data_relation_spec_AST;
}
/**
* Matches a <code>NESTED</code> keyword followed by an optional <code>FOREIGN-KEY-HIDDEN</code>
* keyword. Called by {@link #for_data_relation_spec}.
*/
public final void nested_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast nested_clause_AST = null;
try { // for error handling
Aast tmp353_AST = null;
tmp353_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp353_AST);
match(KW_NESTED);
{
if ((LA(1)==KW_F_KEY_H) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp354_AST = null;
tmp354_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp354_AST);
match(KW_F_KEY_H);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
nested_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = nested_clause_AST;
}
/**
* Matches a <code>RELATION-FIELDS</code> keyword followed by a list of
* one or more {@link #parent_child_field_relation} references. Called by
* {@link #for_data_relation_spec}.
*/
public final void field_mapping_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast field_mapping_clause_AST = null;
try { // for error handling
preferFields = true;
Aast tmp355_AST = null;
tmp355_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp355_AST);
match(KW_REL_FLDS);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
int _cnt251=0;
_loop251:
do {
if ((_tokenSet_64.member(LA(1)))) {
parent_child_field_relation();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_68.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
if ( _cnt251>=1 ) { break _loop251; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt251++;
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
preferFields = false;
field_mapping_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = field_mapping_clause_AST;
}
/**
* Matches a <code>FOR</code> followed by two {@link #record} references
* and options including {@link #field_mapping_clause}. Used by
* {@link #parent_id_relation}.
*/
public final void for_parent_relation_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_parent_relation_spec_AST = null;
Token f = null;
Aast f_AST = null;
try { // for error handling
NameNode nothing = null;
f = LT(1);
f_AST = (Aast)astFactory.create(f);
match(KW_FOR);
hide(f);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
parent_id_field_clause();
astFactory.addASTChild(currentAST, returnAST);
{
_loop240:
do {
if ((LA(1)==KW_PAR_FLDA||LA(1)==KW_PAR_FLDB) && (LA(2)==LPARENS) && (_tokenSet_64.member(LA(3)))) {
parent_fields_ordering_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop240;
}
} while (true);
}
for_parent_relation_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = for_parent_relation_spec_AST;
}
/**
* Matches a <code>PARENT-ID-FIELD</code> followed by an {@link #lvalue} reference.
* <p>
* Used by {@link #for_parent_relation_spec}.
*/
public final void parent_id_field_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast parent_id_field_clause_AST = null;
try { // for error handling
Aast tmp356_AST = null;
tmp356_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp356_AST);
match(KW_PAR_IFLD);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
parent_id_field_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = parent_id_field_clause_AST;
}
/**
* Matches a <code>PARENT-FIELDS-[BEFORE|AFTER]</code> followed by parenthesized list of
* one or more comma separated {@link #lvalue} references.
* <p>
* Used by {@link #for_parent_relation_spec}.
*/
public final void parent_fields_ordering_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast parent_fields_ordering_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_PAR_FLDB:
{
Aast tmp357_AST = null;
tmp357_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp357_AST);
match(KW_PAR_FLDB);
break;
}
case KW_PAR_FLDA:
{
Aast tmp358_AST = null;
tmp358_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp358_AST);
match(KW_PAR_FLDA);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop245:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop245;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
parent_fields_ordering_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = parent_fields_ordering_clause_AST;
}
/**
* Matches a pair of {@link #lvalue} references and roots the pair at a
* <code>PARENT_CHILD_RELATION</code> node. Called by
* {@link #field_mapping_clause}.
*/
public final void parent_child_field_relation() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast parent_child_field_relation_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(PARENT_CHILD_RELATION,""));
lvalue();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
parent_child_field_relation_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_72);
}
returnAST = parent_child_field_relation_AST;
}
/**
* Matches a set of UI oriented keywords and keywords and the required
* following expression. This is the list of keywords matched:
* <pre>
* BGCOLOR
* DCOLOR
* FGCOLOR
* PFCOLOR
* FONT
* CONTEXT_HELP_ID
* COLUMN (allows COLUMNS as a synonym)
* ROW
* MOUSE-POINTER
* COLUMN-BGCOLOR
* COLUMN-DCOLOR
* COLUMN-FGCOLOR
* COLUMN-PFCOLOR
* COLUMN-FONT
* LABEL-BGCOLOR
* LABEL-DCOLOR
* LABEL-FGCOLOR
* LABEL-PFCOLOR
* LABEL-FONT
* ACCELERATOR
* WIDGET-ID
* </pre>
* <p>
* This method has an override for the normal <code>KW_COL expr</code> that can be matched.
* There is a hard coded option in this method to match either <code>KW_COLUMNS</code> or
* <code>KW_COL</code> interchangeably (with a following expression) since the 4GL allows
* this too. This is an undocumented "feature" of the 4GL.
* <p>
* Used by {@link #def_var_stmt} and MANY other locations in the parser.
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple), but this also centralizes the
* logic.
*/
public final void ui_stuff() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast ui_stuff_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_BGCOLOR:
{
Aast tmp359_AST = null;
tmp359_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp359_AST);
match(KW_BGCOLOR);
break;
}
case KW_DCOLOR:
{
Aast tmp360_AST = null;
tmp360_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp360_AST);
match(KW_DCOLOR);
break;
}
case KW_FGCOLOR:
{
Aast tmp361_AST = null;
tmp361_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp361_AST);
match(KW_FGCOLOR);
break;
}
case KW_PFCOLOR:
{
Aast tmp362_AST = null;
tmp362_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp362_AST);
match(KW_PFCOLOR);
break;
}
case KW_FONT:
{
Aast tmp363_AST = null;
tmp363_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp363_AST);
match(KW_FONT);
break;
}
case KW_CTX_H_ID:
{
Aast tmp364_AST = null;
tmp364_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp364_AST);
match(KW_CTX_H_ID);
break;
}
case KW_COL:
{
Aast tmp365_AST = null;
tmp365_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp365_AST);
match(KW_COL);
break;
}
case KW_COLUMNS:
{
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_COLUMNS);
c_AST.setType(KW_COL);
break;
}
case KW_ROW:
{
Aast tmp366_AST = null;
tmp366_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp366_AST);
match(KW_ROW);
break;
}
case KW_MOU_PTR:
{
Aast tmp367_AST = null;
tmp367_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp367_AST);
match(KW_MOU_PTR);
break;
}
case KW_COL_BGC:
{
Aast tmp368_AST = null;
tmp368_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp368_AST);
match(KW_COL_BGC);
break;
}
case KW_COL_DC:
{
Aast tmp369_AST = null;
tmp369_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp369_AST);
match(KW_COL_DC);
break;
}
case KW_COL_FGC:
{
Aast tmp370_AST = null;
tmp370_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp370_AST);
match(KW_COL_FGC);
break;
}
case KW_COL_FONT:
{
Aast tmp371_AST = null;
tmp371_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp371_AST);
match(KW_COL_FONT);
break;
}
case KW_COL_PFC:
{
Aast tmp372_AST = null;
tmp372_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp372_AST);
match(KW_COL_PFC);
break;
}
case KW_LAB_BGC:
{
Aast tmp373_AST = null;
tmp373_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp373_AST);
match(KW_LAB_BGC);
break;
}
case KW_LAB_DC:
{
Aast tmp374_AST = null;
tmp374_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp374_AST);
match(KW_LAB_DC);
break;
}
case KW_LAB_FGC:
{
Aast tmp375_AST = null;
tmp375_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp375_AST);
match(KW_LAB_FGC);
break;
}
case KW_LAB_FONT:
{
Aast tmp376_AST = null;
tmp376_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp376_AST);
match(KW_LAB_FONT);
break;
}
case KW_LAB_PFC:
{
Aast tmp377_AST = null;
tmp377_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp377_AST);
match(KW_LAB_PFC);
break;
}
case KW_ACCEL:
{
Aast tmp378_AST = null;
tmp378_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp378_AST);
match(KW_ACCEL);
break;
}
case KW_WID_ID:
{
Aast tmp379_AST = null;
tmp379_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp379_AST);
match(KW_WID_ID);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
ui_stuff_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = ui_stuff_AST;
}
/**
* Matches the <code>TITLE</code> keyword and the required following string.
* This is the simplified version of {@link #title_phrase}.
* <p>
* Used by {@link #view_as_alert_box_clause}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void simple_title_string() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_title_string_AST = null;
try { // for error handling
Aast tmp380_AST = null;
tmp380_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp380_AST);
match(KW_TITLE);
Aast tmp381_AST = null;
tmp381_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp381_AST);
match(STRING);
simple_title_string_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = simple_title_string_AST;
}
/**
* Matches the <code>LIKE</code> language keyword that defines the name of
* a menu to pattern another menu upon. In this case the type of the
* menu is already known so this has no namespace implications.
* This is called from {@link #def_menu_stmt}. This rule is only separate
* to properly build the AST.
*/
public final void like_menu_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast like_menu_clause_AST = null;
try { // for error handling
Aast tmp382_AST = null;
tmp382_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp382_AST);
match(KW_LIKE);
symbol();
astFactory.addASTChild(currentAST, returnAST);
like_menu_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = like_menu_clause_AST;
}
/**
* Matches the <code>RULE or SKIP</code> keywords or the other possible
* constructs {@link #menu_item_phrase} and {@link #submenu_descriptor} that
* can be used as a menu element. Called from {@link #def_menu_stmt}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* <code>SUB-MENU</code> keyword.
*/
public final void menu_element_descriptor() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast menu_element_descriptor_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_RULE:
{
Aast tmp383_AST = null;
tmp383_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp383_AST);
match(KW_RULE);
break;
}
case KW_SKIP:
{
Aast tmp384_AST = null;
tmp384_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp384_AST);
match(KW_SKIP);
break;
}
case KW_SUB_MENU:
{
submenu_descriptor();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_MENU_ITM:
{
menu_item_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
menu_element_descriptor_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = menu_element_descriptor_AST;
}
/**
* Matches the <code>SUB-MENU</code> keyword with following sub-menu name
* and options. This is used in a {@link #menu_element_descriptor}.
* <p>
* At this time, the <code>symbol</code> is a placeholder for proper
* menu namespace processing.
* <p>
* This is very similar to the {@link #menu_reference} rule but it includes
* a more specific keyword and has options. The two rules can't be used as
* alternatives because they are ambiguous.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* <code>SUB-MENU</code> keyword.
*/
public final void submenu_descriptor() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast submenu_descriptor_AST = null;
try { // for error handling
Aast tmp385_AST = null;
tmp385_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp385_AST);
match(KW_SUB_MENU);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop263:
do {
if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DISABLED) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp386_AST = null;
tmp386_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp386_AST);
match(KW_DISABLED);
}
else {
break _loop263;
}
} while (true);
}
submenu_descriptor_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = submenu_descriptor_AST;
}
/**
* Matches a <code>MENU-ITEM</code> definition in the Progress 4GL
* <code>DEFINE MENU or DEFINE SUB-MENU</code> language statements.
* Menus, sub-menus and menu-items are stored in their own namespace which is
* separate from the other widgets, though at this time there is no actual
* menu namespace processing in this parser.
* <p>
* This rule is called by {@link #menu_element_descriptor}.
* <p>
* This rule matches the <code>MENU-ITEM</code> keyword and all
* subsequent processing. Calls the following rules:
* <p>
* {@link #symbol}
* {@link #label}
* {@link #ui_stuff}
* <p>
* All options can be processed in any order.
* <p>
* The <code>ui_stuff</code> rule generates bogus ambiguity warnings with
* the exit branch of the loop. Ambiguity warnings have been disabled.
*/
public final void menu_item_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast menu_item_phrase_AST = null;
Aast itm_AST = null;
try { // for error handling
Aast tmp387_AST = null;
tmp387_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp387_AST);
match(KW_MENU_ITM);
symbol();
itm_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop266:
do {
if ((LA(1)==KW_READ_ONL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp388_AST = null;
tmp388_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp388_AST);
match(KW_READ_ONL);
}
else if ((LA(1)==KW_TOGGL_BX) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp389_AST = null;
tmp389_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp389_AST);
match(KW_TOGGL_BX);
}
else if ((LA(1)==KW_DISABLED) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp390_AST = null;
tmp390_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp390_AST);
match(KW_DISABLED);
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TRIGGERS) && (LA(2)==DOT||LA(2)==COLON) && (LA(3)==KW_END||LA(3)==KW_ON)) {
trigger_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop266;
}
} while (true);
}
menu_item_phrase_AST = (Aast)currentAST.root;
String txt = itm_AST.getText();
sym.addMenuItem(txt, WID_MENU_ITM);
// pass the AST with all options to the symbol resolver to set
// those variable options accordingly
sym.setVariableOptions(txt, menu_item_phrase_AST);
// write any non-standard options into annotations
sym.annotateVariableOptions(txt, menu_item_phrase_AST, true);
menu_item_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = menu_item_phrase_AST;
}
/**
* Matches the <code>TRIGGERS</code> keyword and the following trigger phrase
* construct. This is used in the {@link #def_var_stmt},
* {@link #def_button_stmt} and {@link #menu_item_phrase} rules.
* <p>
* Calls the {@link #simple_on_stmt} rule to implement the actual event
* matching and trigger block. Uses {@link #end_stmt} to delimit the
* block. This rule does NOT eat the trailing <code>DOT</code> since it is
* called inline from other language statements.
* <p>
* Though it is not documented, it is possible to use either a
* <code>DOT or COLON</code> after the <code>TRIGGERS</code> keyword. This
* is supported. Note that although in many locations in Progress, 2
* nearly identical keywords are both matched as the documented keyword
* (e.g. {@link #buttons_clause} or {@link #field_list}),
* the <code>TRIGGER</code> keyword does NOT work in Progress, thus we
* provide no support for it here.
* <p>
* Although the 4GL documentation shows that at least one {@link #simple_on_stmt} is required
* to be present, customer code has shown that it is optional. This undocumented feature is
* supported.
* <p>
* Bogus ANTLR ambiguity warnings have been suppressed.
*/
public final void trigger_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast trigger_phrase_AST = null;
try { // for error handling
Aast tmp391_AST = null;
tmp391_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp391_AST);
match(KW_TRIGGERS);
block_term();
astFactory.addASTChild(currentAST, returnAST);
{
_loop850:
do {
if ((LA(1)==KW_ON)) {
simple_on_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop850;
}
} while (true);
}
end_stmt(false);
astFactory.addASTChild(currentAST, returnAST);
trigger_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = trigger_phrase_AST;
}
/**
* Matches a set of image oriented keywords and keywords and the required
* following {@link #image_phrase}. This is the list of keywords matched:
* <pre>
* IMAGE
* IMAGE-DOWN
* IMAGE-INSENSITIVE
* IMAGE-UP
* </pre>
* <p>
* Used by {@link #def_button_stmt} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void image_stuff() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast image_stuff_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_IMAGE:
{
Aast tmp392_AST = null;
tmp392_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp392_AST);
match(KW_IMAGE);
break;
}
case KW_IMG_DOWN:
{
Aast tmp393_AST = null;
tmp393_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp393_AST);
match(KW_IMG_DOWN);
break;
}
case KW_IMG_INS:
{
Aast tmp394_AST = null;
tmp394_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp394_AST);
match(KW_IMG_INS);
break;
}
case KW_IMG_UP:
{
Aast tmp395_AST = null;
tmp395_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp395_AST);
match(KW_IMG_UP);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
image_phrase();
astFactory.addASTChild(currentAST, returnAST);
image_stuff_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = image_stuff_AST;
}
/**
* Matches the <code>LIKE</code> language keyword that defines the name of
* a widget to pattern another widget upon. In this case the type of the
* widget is already known so this has no namespace implications.
* This is called from {@link #def_button_stmt} and other locations which all
* handle the same syntax. This allows the logic to be centralized and
* reused from multiple callers. This rule is only separate to properly
* build the AST.
*/
public final void like_widget_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast like_widget_clause_AST = null;
try { // for error handling
Aast tmp396_AST = null;
tmp396_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp396_AST);
match(KW_LIKE);
widget();
astFactory.addASTChild(currentAST, returnAST);
like_widget_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = like_widget_clause_AST;
}
/**
* Matches the size phrase construct of the Progress 4GL language.
* This rule is called from {@link #frame_phrase} rule et al.
*/
public final void size_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast size_phrase_AST = null;
Token by = null;
Aast by_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_SIZE:
{
Aast tmp397_AST = null;
tmp397_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp397_AST);
match(KW_SIZE);
break;
}
case KW_SIZE_C:
{
Aast tmp398_AST = null;
tmp398_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp398_AST);
match(KW_SIZE_C);
break;
}
case KW_SIZE_P:
{
Aast tmp399_AST = null;
tmp399_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp399_AST);
match(KW_SIZE_P);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
by = LT(1);
by_AST = (Aast)astFactory.create(by);
match(KW_BY);
hide(by);
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
size_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = size_phrase_AST;
}
/**
* Matches the <code>NO-FOCUS</code> keyword and the optional following
* <code>FLAT-BUTTON</code>. Used by {@link #def_button_stmt} and the subtree
* is rooted by the keyword (which is the reason for using a separate rule
* for something so simple).
*/
public final void no_focus_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast no_focus_clause_AST = null;
try { // for error handling
Aast tmp400_AST = null;
tmp400_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp400_AST);
match(KW_NO_FOCUS);
{
if ((LA(1)==KW_FLAT_BUT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp401_AST = null;
tmp401_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp401_AST);
match(KW_FLAT_BUT);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
no_focus_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = no_focus_clause_AST;
}
/**
* Matches the <code>TOOLTIP</code> clause as used in a phrase from a
* <code>VIEW-AS</code> construct. See {@link #view_as_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void tooltip_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast tooltip_clause_AST = null;
try { // for error handling
Aast tmp402_AST = null;
tmp402_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp402_AST);
match(KW_TOOLTIP);
literal();
astFactory.addASTChild(currentAST, returnAST);
tooltip_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = tooltip_clause_AST;
}
/**
* Matches the <code>EDGE-CHARS or EDGE-PIXELS</code> construct of the
* Progress 4GL language. This rule is called from the {@link #def_rect_stmt}
* rule.
*/
public final void edge_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast edge_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_EDGE_C:
{
Aast tmp403_AST = null;
tmp403_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp403_AST);
match(KW_EDGE_C);
break;
}
case KW_EDGE_P:
{
Aast tmp404_AST = null;
tmp404_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp404_AST);
match(KW_EDGE_P);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
edge_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = edge_clause_AST;
}
/**
* Support the <code>STRETCH-TO-FIT</code> with an optional
* <code>RETAIN-SHAPE</code>. This is separated to properly build the tree
* rooted at the <code>KW_ST_2_FIT</code> node. Called from
* {@link #def_image_stmt}
*/
public final void stretch_to_fit_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast stretch_to_fit_clause_AST = null;
try { // for error handling
Aast tmp405_AST = null;
tmp405_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp405_AST);
match(KW_ST_2_FIT);
{
if ((LA(1)==KW_RET_SHAP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp406_AST = null;
tmp406_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp406_AST);
match(KW_RET_SHAP);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stretch_to_fit_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = stretch_to_fit_clause_AST;
}
/**
* Matches the image phrase which is called from a {@link #def_button_stmt}
* or a {@link #def_image_stmt}. The first token must be the
* <code>KW_FILE</code> followed by a {@link #filename}. Also uses the
* following:
* <p>
* <ul>
* <li> {@link #image_size_clause}
* <li> {@link #from_clause}
* </ul>
* <p>
* Also allows a match to the <code>KW_FIL_NAME</code> token instead of the
* <code>KW_FILE</code>. This is an undocumented feature found in real 4GL
* code. We normalize the parent to KW_FILE in this case to simplify downstream
* use.
*/
public final void image_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast image_phrase_AST = null;
Token f = null;
Aast f_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_FILE:
case KW_FIL_NAME:
{
{
switch ( LA(1)) {
case KW_FILE:
{
Aast tmp407_AST = null;
tmp407_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp407_AST);
match(KW_FILE);
break;
}
case KW_FIL_NAME:
{
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.makeASTRoot(currentAST, f_AST);
match(KW_FIL_NAME);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
if (f_AST != null) f_AST.setType(KW_FILE);
{
if (((LA(1) >= KW_IMG_SZ && LA(1) <= KW_IMG_SZ_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
image_size_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case KW_IMG_SZ:
case KW_IMG_SZ_C:
case KW_IMG_SZ_P:
{
image_size_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_FROM) && (_tokenSet_73.member(LA(2))) && (_tokenSet_74.member(LA(3)))) {
from_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
image_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = image_phrase_AST;
}
/**
* Matches the shorthand of specifying a record (and optional exclude list
* of fields) instead of an explicit field list, in the
* {@link #def_frame_stmt}, {@link #display_stmt} and {@link #column_spec}
* rules. Uses {@link #except_list}.
* <p>
* This rule is naturally greedy (in matching a list of field names to
* exclude, and doing so in a loop. ANTLR warns that this causes ambiguity.
* The greedy option is used to tell ANTLR to disable the warning, though it
* has no impact on the actual code generation.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
* <p>
* If a non-null <code>fields</code> argument is provided, a bogus AST will be
* manufactured to represent a business logic reference to each field in the
* database table represented by the record spec. These are used downstream for
* schema-level field assign validation processing.
* <p>
* TBD: we always promote the associated table here, though it is unclear
* whether this is necessary in the {@link #form_stmt} case.
*
* @param fields
* Set into which manufactured field references should be stored. May be
* <code>null</code>.
*/
public final void record_spec(
Set<Aast> fields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast record_spec_AST = null;
Aast r_AST = null;
try { // for error handling
NameNode nothing = null;
nothing=record(true, false, false);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_EXCEPT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
except_list(null);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if (fields != null)
{
String sname = (String) r_AST.getAnnotation("schemaname");
String bufname = (String) r_AST.getAnnotation("bufname");
Iterator<Aast> iter = sym.fields(sname);
while (iter.hasNext())
{
Aast fld = iter.next();
String fname = fld.getText();
// manufacture bogus field reference AST with bufname and schemaname annotations
Aast fldRef = new ProgressAst();
fldRef.setType(fld.getType());
fldRef.setText(bufname + "." + fname);
fldRef.putAnnotation("schemaname", sname + "." + fname);
fldRef.putAnnotation("bufname", bufname);
fields.add(fldRef);
}
}
record_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = record_spec_AST;
}
/**
* Matches the form item construct of the Progress 4GL language. Calls
* {@link #space_or_skip}, {@link #widget} and {@link #expr}. Called by
* {@link #def_frame_stmt} and {@link #form_stmt}. The resulting tree will be
* rooted at a <code>FORM_ITEM</code> token.
* <p>
* This is ambiguity between the {@link #widget} rule and the expression/
* variable definition mode where the rule uses a {@link #symbol}
* for matching. Since both rules can can reference a symbol in the
* leftmost position, lookups are done in the widget namespace to
* disambiguate (in a semantic predicate) the widget option and the
* expression path (with modified matching) is used for both the variable
* definition and general expressions.
* <p>
* New variables can be defined using the the format phrase with an embedded
* <code>AS or LIKE</code> clause! The <code>AS or LIKE</code> clause can
* be arbitrarily deep in the format phrase so we enable a special mode of
* the {@link #expr} processing that allows {@link #lvalue} to match with
* a <code>SYMBOL</code>. This overcomes the limitations of fixed lookahead
* cause (where the <code>AS or LIKE</code> keywords cannot be found in the
* 2nd token).
* <p>
* Another unsupported feature of Progress is the implicit scoping of a
* qualified variable name (when a field is referenced - this will be
* matched by the expression alternative) to the unqualified version. Thus
* a name like tablename.fieldname can be referenced in the following
* format phrase as fieldname, even though it would normally be ambiguous.
* To work around this, hints can be used to define a variable of the
* appropriate name with the proper <code>FIELD_</code> token type.
* <p>
* The use of the {@link #format_phrase} following an expression is ambiguous
* since it includes rule references that include options that include
* expressions. Thus, the lookahead set for the format phrase is quite
* large and this naturally can conflict with following constructs in the
* form item's calling rule(s). A review of the code does not show any
* problems and no false positives have been encountered yet. Ambiguity
* warnings for this case have been disabled but this location bears
* watching. Similar ambiguities exist for the aggregate phrase, the use of
* which is an undocumented feature in the form statement. This rules does
* allow this usage.
*
* @param fields
* Set into which a field reference should be stored, if the form item
* represents a database field.
*/
public final void form_item(
Set<Aast> fields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast form_item_AST = null;
Aast w_AST = null;
Aast e_AST = null;
try { // for error handling
String symbolName = null;
Aast fld = null;
Aast child = null;
int numFP = 0;
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(FORM_ITEM,"form item"));
{
if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
sym.lookupWidget(LT(1).getText()) != -1 &&
sym.lookupVariable(LT(1).getText()) == -1 &&
!sym.isFieldExactName(LT(1).getText())
)) {
widget();
w_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
allowSymbolMatch = true;
allowStringMatch = true;
excludeFrame = true;
// TODO: Determine what downstream affects there might be before enabling
// preferDefaultBuffer = true;
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
allowSymbolMatch = false;
allowStringMatch = false;
excludeFrame = false;
// preferDefaultBuffer = false;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
// setup for the format phrase processing which may involve
// a variable definition or
if (e_AST != null)
{
child = e_AST.getChildAt(0);
if (child != null && child.getType() == SYMBOL)
{
symbolName = child.getText();
}
else
{
fld = findFieldNode(e_AST);
if (fld != null && LA(1) == KW_LIKE)
{
symbolName = fld.getText();
fld.setType(SYMBOL);
fld = null;
}
}
}
else if (w_AST != null)
{
fld = findFieldNode(w_AST);
}
{
_loop298:
do {
if ((LA(1)==LPARENS) && (_tokenSet_75.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
aggregate_phrase();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( numFP < 2 )) {
format_phrase(symbolName, fld, true, false);
astFactory.addASTChild(currentAST, returnAST);
numFP++;
}
else {
break _loop298;
}
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
form_item_AST = (Aast)currentAST.root;
// fixup the tree to remove the expression node if this was a
// variable definition
if (symbolName != null)
{
// the Aast helper methods can't be used here because they are
// dependent upon parent nodes or try to fixup IDs that don't
// exist yet
child.setNextSibling(e_AST.getNextSibling());
form_item_AST.setFirstChild(child);
}
if (fld != null)
{
fields.add(fld);
}
form_item_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = form_item_AST;
}
/**
* Matches the frame phrase construct of the Progress 4GL language which
* always begins with the <code>WITH</code> keyword. All of its options
* can be specified in any order. In fact, this can be an empty phrase
* with nothing following the keyword (undocumented feature). As another
* undocumented and useless feature, one can insert any number of whitespace
* delimited <code>WITH</code> keywords in between any option and it will
* parse and work as if these extra keywords did not exist. This is probably
* just in fact allowing multiple sequential frame phrases (with any of them
* being empty), but in this rule we just drop the extra <code>WITH</code>
* keyword and parse everything into a single frame phrase. This should be
* logically equivalent.
* <p>
* The following list of rules are called to properly implement the tree
* building (which will be rooted at a <code>FRAME_PHRASE</code> token):
* <p>
* <ul>
* <li> {@link #accum_clause}
* <li> {@link #at_phrase}
* <li> {@link #button_reference}
* <li> {@link #color_spec}
* <li> {@link #context_help_file}
* <li> {@link #frame_reference}
* <li> {@link #size_phrase}
* <li> {@link #lvalue} (only for stream and browse references, protected with a semantic predicate)
* <li> {@link #title_phrase}
* <li> {@link #version_6_frame_clause}
* <li> {@link #view_as_dialog_clause}
* <li> {@link #in_window_clause}
* <li> {@link #misc_frame_opts}
* <li> {@link #columns_clause}
* <li> {@link #down_clause}
* </ul>
* <p>
* The order of the above list is important in the case of the last two
* rule references {@link #columns_clause} and {@link #down_clause}. These
* prefix a <code>whole_number_literal</code> and an expression respectively to
* a keyword which is inherently ambiguous. The ambiguity is resolved by
* the careful ordering of these alternatives. Based on the complicated
* loop closure rule needed to process these options in any order, the
* k=2 lookahead is often being checked to confirm that a following
* token is seen before a match is made. This logic has been reviewed and
* many cases have been tested, however all possible cases cannot be tested.
* For this reason, one must watch this rule carefully. We have disabled
* ambiguity warnings and it is thought that this is safe, but great care
* must be taken to confirm this over time.
* <p>
* Called from {@link #do_repeat_stmt}, {@link #for_stmt} and
* {@link #def_frame_stmt} among other locations.
*
* @param blockHdr
* <code>true</code> if this frame phrase is being called from
* within a block header (which will change its matching logic
* to allow it to avoid matching with possible following keywords
* in the calling rule).
* @param editing
* <code>true</code> if this frame phrase can be followed by an
* editing block.
*/
public final void frame_phrase(
boolean blockHdr, boolean editing
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast frame_phrase_AST = null;
Token w = null;
Aast w_AST = null;
Token wi = null;
Aast wi_AST = null;
try { // for error handling
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.makeASTRoot(currentAST, w_AST);
match(KW_WITH);
w_AST.setType(FRAME_PHRASE);
{
_loop367:
do {
if ((LA(1)==KW_WITH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
wi = LT(1);
wi_AST = (Aast)astFactory.create(wi);
match(KW_WITH);
hide(wi);
}
else if ((LA(1)==KW_ACCUM) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
accum_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_AT) && (_tokenSet_76.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
at_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_ATTR||LA(1)==KW_NO_ATTR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_ATTR:
{
Aast tmp408_AST = null;
tmp408_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp408_AST);
match(KW_ATTR);
break;
}
case KW_NO_ATTR:
{
Aast tmp409_AST = null;
tmp409_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp409_AST);
match(KW_NO_ATTR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_CANCEL_B||LA(1)==KW_DEFLT_BN) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
button_reference();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CENTER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp410_AST = null;
tmp410_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp410_AST);
match(KW_CENTER);
}
else if ((LA(1)==KW_COLOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
color_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CTX_H) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp411_AST = null;
tmp411_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp411_AST);
match(KW_CTX_H);
}
else if ((LA(1)==KW_CTX_H_F) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
context_help_file();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DROP_TAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp412_AST = null;
tmp412_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp412_AST);
match(KW_DROP_TAR);
}
else if ((LA(1)==KW_EXPORT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp413_AST = null;
tmp413_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp413_AST);
match(KW_EXPORT);
}
else if ((LA(1)==KW_FRAME) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
frame_reference(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_INH_BGC||LA(1)==KW_NO_INHBG) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_INH_BGC:
{
Aast tmp414_AST = null;
tmp414_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp414_AST);
match(KW_INH_BGC);
break;
}
case KW_NO_INHBG:
{
Aast tmp415_AST = null;
tmp415_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp415_AST);
match(KW_NO_INHBG);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_INH_FGC||LA(1)==KW_NO_INHFG) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_INH_FGC:
{
Aast tmp416_AST = null;
tmp416_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp416_AST);
match(KW_INH_FGC);
break;
}
case KW_NO_INHFG:
{
Aast tmp417_AST = null;
tmp417_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp417_AST);
match(KW_NO_INHFG);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_KEEP_TAB) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp418_AST = null;
tmp418_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp418_AST);
match(KW_KEEP_TAB);
}
else if ((LA(1)==KW_NO_BOX) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp419_AST = null;
tmp419_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp419_AST);
match(KW_NO_BOX);
}
else if ((LA(1)==KW_NO_HIDE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp420_AST = null;
tmp420_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp420_AST);
match(KW_NO_HIDE);
}
else if ((LA(1)==KW_NO_LABEL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp421_AST = null;
tmp421_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp421_AST);
match(KW_NO_LABEL);
}
else if ((LA(1)==KW_USE_DCT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp422_AST = null;
tmp422_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp422_AST);
match(KW_USE_DCT);
}
else if ((LA(1)==KW_NO_VALID) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp423_AST = null;
tmp423_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp423_AST);
match(KW_NO_VALID);
}
else if ((LA(1)==KW_NO_AUTOV) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp424_AST = null;
tmp424_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp424_AST);
match(KW_NO_AUTOV);
}
else if ((LA(1)==KW_NO_HELP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp425_AST = null;
tmp425_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp425_AST);
match(KW_NO_HELP);
}
else if ((LA(1)==KW_NO_UNDL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp426_AST = null;
tmp426_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp426_AST);
match(KW_NO_UNDL);
}
else if ((LA(1)==KW_OVERLAY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp427_AST = null;
tmp427_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp427_AST);
match(KW_OVERLAY);
}
else if ((LA(1)==KW_PAGE_B||LA(1)==KW_PAGE_T) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_PAGE_B:
{
Aast tmp428_AST = null;
tmp428_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp428_AST);
match(KW_PAGE_B);
break;
}
case KW_PAGE_T:
{
Aast tmp429_AST = null;
tmp429_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp429_AST);
match(KW_PAGE_T);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_SCRN_IO||LA(1)==KW_STRM_IO) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SCRN_IO:
{
Aast tmp430_AST = null;
tmp430_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp430_AST);
match(KW_SCRN_IO);
break;
}
case KW_STRM_IO:
{
Aast tmp431_AST = null;
tmp431_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp431_AST);
match(KW_STRM_IO);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_SCROLLBL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp432_AST = null;
tmp432_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp432_AST);
match(KW_SCROLLBL);
}
else if ((LA(1)==KW_SCROLL_V) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp433_AST = null;
tmp433_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp433_AST);
match(KW_SCROLL_V);
}
else if ((LA(1)==KW_SIDE_L) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp434_AST = null;
tmp434_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp434_AST);
match(KW_SIDE_L);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_3D) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp435_AST = null;
tmp435_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp435_AST);
match(KW_3D);
}
else if ((LA(1)==KW_TITLE) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
title_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOP_ONLY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp436_AST = null;
tmp436_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp436_AST);
match(KW_TOP_ONLY);
}
else if ((LA(1)==KW_USE_TXT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp437_AST = null;
tmp437_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp437_AST);
match(KW_USE_TXT);
}
else if ((LA(1)==KW_V6FRAME) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp438_AST = null;
tmp438_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp438_AST);
match(KW_V6FRAME);
}
else if ((LA(1)==KW_USE_REV) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp439_AST = null;
tmp439_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp439_AST);
match(KW_USE_REV);
}
else if ((LA(1)==KW_USE_UND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp440_AST = null;
tmp440_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp440_AST);
match(KW_USE_UND);
}
else if ((LA(1)==KW_VIEW_AS) && (LA(2)==KW_DIALOG) && (_tokenSet_3.member(LA(3)))) {
view_as_dialog_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_IN) && (LA(2)==KW_WINDOW) && (_tokenSet_24.member(LA(3)))) {
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_67.member(LA(1))) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
misc_frame_opts();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND || LA(1) == KW_BROWSE )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==HEX_LITERAL||LA(1)==NUM_LITERAL) && (LA(2)==KW_COLUMNS||LA(2)==KW_COL) && (_tokenSet_3.member(LA(3)))) {
columns_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
blockHdr &&
LA(1) != KW_TRANS &&
(LA(1) == KW_DOWN || isValidLeftmostReserved(LT(1), LT(2)))
)) {
down_clause_or_loop_incr();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!blockHdr &&
(LA(1) == KW_DOWN || !editing || (LA(2) != DOT && LA(2) != COLON)) &&
LA(1) != KW_NO_ERROR
)) {
down_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop367;
}
} while (true);
}
frame_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = frame_phrase_AST;
}
/**
* Matches a <code>FORM</code> Progress 4GL language statement which is
* nearly identical to the {@link #def_frame_stmt}.
* <p>
* The tricky part of this statement is handling the options in any order and
* resolving the ambiguity between the record and field specifications.
* Records are disambiguated from fields (records take precedence when there
* is a name conflict) by trying to do a lookup, if it fails the record is
* not matched (see {@link #record_spec}) and instead the {@link #form_item}
* is checked. By carefully ordering these options and using a semantic
* predicate, the ambiguity is resolved. For this reason, ambiguity warnings
* have been disabled.
* <p>
* Called by {@link #stmt_list}. Uses {@link #record_spec},
* {@link #form_item} and {@link #frame_phrase} to properly build the AST.
* <p>
* Progress is so ridiculously ambiguous about keywords that there is a
* reserved <code>FORMAT</code> keyword that can be abbreviated down to
* 4 characters. Yes, the reserved <code>FORM</code> keyword could actually
* be the <code>FORMAT</code> keyword and must be disambiguated by context.
* Our keyword processing will always generate a match to <code>FORMAT</code>
* and we override it to be a <code>FORM</code>, once we match here.
*/
public final void form_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast form_stmt_AST = null;
Token f = null;
Aast f_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
String frame = "";
boolean hadFormItem = false;
boolean hadRecord = false;
boolean hadHeader = false;
inFormStatement = true;
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.makeASTRoot(currentAST, f_AST);
match(KW_FORMAT);
f_AST.setType(KW_FORM);
{
_loop288:
do {
if ((LA(1)==KW_BACKGRND||LA(1)==KW_HEADER) && (_tokenSet_77.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_HEADER:
{
Aast tmp441_AST = null;
tmp441_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp441_AST);
match(KW_HEADER);
break;
}
case KW_BACKGRND:
{
Aast tmp442_AST = null;
tmp442_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp442_AST);
match(KW_BACKGRND);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
hadHeader = true;
}
else if (((_tokenSet_13.member(LA(1))) && (_tokenSet_77.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!hadFormItem &&
!hadHeader &&
isRecord(LT(1).getText()) &&
(LA(2) == KW_EXCEPT || LA(2) == KW_WITH || LA(2) == DOT)
)) {
record_spec(fields);
astFactory.addASTChild(currentAST, returnAST);
hadRecord = true;
}
else if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&(
!(LA(1) == DOT || LA(1) == KW_WITH || LA(1) == KW_HEADER || LA(1) == KW_BACKGRND) &&
(!hadRecord || hadHeader)
)) {
form_item(fields);
astFactory.addASTChild(currentAST, returnAST);
hadFormItem = true;
}
else if ((LA(1)==KW_WITH) && (_tokenSet_77.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (frame.length() == 0)
{
String name = getFrameName(fp_AST);
if (name.length() > 0)
{
frame = name;
}
}
}
else {
break _loop288;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
form_stmt_AST = (Aast)currentAST.root;
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
setUseDictExps(frame, fp_AST, form_stmt_AST);
inFormStatement = false;
form_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = form_stmt_AST;
}
/**
* Specifies an list of fields that are not excluded from the previous record
* or query definition.
* <p>
* Used by {@link #record_spec} and {@link #browse_all_list}.
* <p>
* This rule is naturally greedy (in matching a list of field names to
* exclude, and doing so in a loop. ANTLR warns that this causes ambiguity.
* The greedy option is used to tell ANTLR to disable the warning, though it
* has no impact on the actual code generation.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*
* @param exceptFields
* A set to collect the fully qualified field names or <code>null</code> if not required.
*/
public final void except_list(
Set<String> exceptFields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast except_list_AST = null;
Aast l_AST = null;
try { // for error handling
Aast tmp443_AST = null;
tmp443_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp443_AST);
match(KW_EXCEPT);
{
_loop293:
do {
if ((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (exceptFields != null && l_AST.isAnnotation("schemaname"))
{
exceptFields.add((String) l_AST.getAnnotation("schemaname"));
}
}
else {
break _loop293;
}
} while (true);
}
except_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = except_list_AST;
}
/**
* Matches the <code>SPACE() or SKIP()</code> constructs and the optional
* following numeric constant. Note that although ANTLR reports ambiguity
* in the optional clause, there is no actual ambiguity so warnings have
* been disabled.
* <p>
* Used by {@link #form_item}, {@link #set_or_update_or_prompt_for_stmt },
* {@link #display_stmt}, {@link #enable_stmt}, {@link #export_stmt},
* {@link #column_spec} and {@link #content_array} (used in a
* <code>MESSAGE</code> statement).
* <p>
* The subtree is rooted by the keyword.
*/
public final void space_or_skip() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast space_or_skip_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_SPACE:
{
Aast tmp444_AST = null;
tmp444_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp444_AST);
match(KW_SPACE);
break;
}
case KW_SKIP:
{
Aast tmp445_AST = null;
tmp445_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp445_AST);
match(KW_SKIP);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LPARENS) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==RPARENS)) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
space_or_skip_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = space_or_skip_AST;
}
/**
* Matches all Progress 4GL widget names that exist in the variable
* namespace (which is the namespace in which Progress stores them).
* <p>
* This rule is simply a convenience method to use the prefer widgets
* flag to bias the rule reference to {@link #lvalue} to first
* pick a widget over a variable. When done, the prefer widgets flag
* state is set back to the default of <code>false</code>.
*/
public final void widget() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast widget_AST = null;
try { // for error handling
preferWidgets = true;
lvalue();
astFactory.addASTChild(currentAST, returnAST);
preferWidgets = false;
widget_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = widget_AST;
}
/**
* Matches an aggregate phrase, most often used in the <code>DISPLAY</code> language statement. There is
* an undocumented feature in the 4GL where the SQL keyword SUM can be used as a synonym for TOTAL. This
* rule rewrites KW_SUM as KW_TOTAL.
* <p>
* Called by {@link #display_stmt}. Uses {@link #label} and {@link #by_clause}.
* <p>
* <b>This rule uses a trick to create an artificial node as a root while still allowing ANTLR to do normal
* tree building (no suppression of the AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used such that the contents of the loop
* cannot be referenced in a manually built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4)
* the ability to label a loop such that the entire contents can be referenced. If one labels the individual
* elements inside the loop, only the last one is available when the loop concludes. However, by leaving the
* normal tree creation unchanged but manually creating an artificial node and manually setting this node as
* the root of the returned tree BEFORE the children are added, this problem can be solved.
* <p>
* When the {@link #accum_function} was added, ANTLR started showing bogus ambiguity warnings. These have
* been disabled.
*/
public final void aggregate_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast aggregate_phrase_AST = null;
Token t = null;
Aast t_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(AGGREGATE,"aggregate"));
{
_loop352:
do {
if ((_tokenSet_78.member(LA(1))) && (_tokenSet_79.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_AVERAGE:
{
Aast tmp446_AST = null;
tmp446_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp446_AST);
match(KW_AVERAGE);
break;
}
case KW_AVG:
{
t = LT(1);
t_AST = (Aast)astFactory.create(t);
astFactory.addASTChild(currentAST, t_AST);
match(KW_AVG);
// 'AVG' is an alias for AVERAGE at accumulators
t_AST.setType(KW_AVERAGE);
break;
}
case KW_COUNT:
{
Aast tmp447_AST = null;
tmp447_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp447_AST);
match(KW_COUNT);
break;
}
case KW_MAX:
{
Aast tmp448_AST = null;
tmp448_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp448_AST);
match(KW_MAX);
break;
}
case KW_MIN:
{
Aast tmp449_AST = null;
tmp449_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp449_AST);
match(KW_MIN);
break;
}
case KW_TOTAL:
{
Aast tmp450_AST = null;
tmp450_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp450_AST);
match(KW_TOTAL);
break;
}
case KW_SUM:
{
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.addASTChild(currentAST, s_AST);
match(KW_SUM);
s_AST.setType(KW_TOTAL);
break;
}
case KW_SUB_AVG:
{
Aast tmp451_AST = null;
tmp451_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp451_AST);
match(KW_SUB_AVG);
break;
}
case KW_SUB_CNT:
{
Aast tmp452_AST = null;
tmp452_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp452_AST);
match(KW_SUB_CNT);
break;
}
case KW_SUB_MAX:
{
Aast tmp453_AST = null;
tmp453_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp453_AST);
match(KW_SUB_MAX);
break;
}
case KW_SUB_MIN:
{
Aast tmp454_AST = null;
tmp454_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp454_AST);
match(KW_SUB_MIN);
break;
}
case KW_SUB_TOT:
{
Aast tmp455_AST = null;
tmp455_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp455_AST);
match(KW_SUB_TOT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_80.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop351:
do {
if ((LA(1)==KW_BY) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
by_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop351;
}
} while (true);
}
}
else {
break _loop352;
}
} while (true);
}
aggregate_phrase_AST = (Aast)currentAST.root;
if (aggregate_phrase_AST.getNumberOfChildren() == 0)
{
aggregate_phrase_AST = null;
}
currentAST.root = aggregate_phrase_AST;
currentAST.child = aggregate_phrase_AST!=null &&aggregate_phrase_AST.getFirstChild()!=null ?
aggregate_phrase_AST.getFirstChild() : aggregate_phrase_AST;
currentAST.advanceChildToEnd();
aggregate_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_79);
}
returnAST = aggregate_phrase_AST;
}
/**
* Matches the format phrase construct of the Progress 4GL language which
* optionally appears in a referencing rule but does not begin with a specific
* keyword. All of its options can be specified in any order.
* <p>
* The following list of rules are called to properly implement the tree
* building (which will be rooted at a <code>FORMAT_PHRASE</code> token):
* <p>
* <ul>
* <li> {@link #at_phrase}
* <li> {@link #as_clause}
* <li> {@link #like_clause}
* <li> {@link #colon_constant}
* <li> {@link #to_constant}
* <li> {@link #column_label}
* <li> {@link #format_string}
* <li> {@link #help_string}
* <li> {@link #label}
* <li> {@link #validate}
* <li> {@link #ui_stuff}
* <li> {@link #view_as_phrase}
* <li> {@link #simple_when_clause}
* <li> {@link #at_base_field_clause}
* </ul>
* <p>
* Ambiguity is caused by the use of unreserved keywords in the leftmost
* position combined with a loop that has a mixture of single and multiple
* token alternatives and a rule reference that includes an expression
* starting in the second token position. Based on the complicated
* loop closure rule needed to process these options in any order, the
* k=2 lookahead is sometimes being checked to confirm that a following
* token is seen before a match is made. This logic has been reviewed and
* many cases have been tested, however all possible cases cannot be tested.
* For this reason, one must watch this rule carefully. We have disabled
* ambiguity warnings and it is thought that this is safe, but great care
* must be taken to confirm this over time.
* <p>
* Called from {@link #form_item}.
* <p>
* The <code>WHEN</code> clause (accessed via <code>simple_when_clause</code>)
* is not documented as part of the format phrase, BUT customer examples
* show that this can be embedded inside one. Rather than try to handle
* all the individual locations where such a highly variable construct
* (format phrase -> when phrase -> format phrase), it is more natural to
* simply include it in the format phrase as we have done (probably just as
* Progress does this internally).
* <p>
* The '@' base_field clause (accessed via <code>at_base_field_clause</code>)
* is not documented as part of this phrase but customer examples show that
* this can be embedded inside one. See the paragraph above on the when
* clause.
* <p>
* The undocumented option <code>PASSWORD-FIELD</code> is matched here. It was
* found in customer source code.
* <p>
* When called from frame definition statements, this will match the undocumented option
* <code>AS BUTTON</code> which is the equivalent of an inline <code>DEFINE BUTTON</code>
* statement. This is a quirk of the 4GL. The 4GL doesn't provide this same functionality
* for any other widget types. The other configuration of the format phrase will modify the
* new button widget, as you would expect.
*
* @param symName
* If not <code>null</code> then a variable definition will be
* processed and the format phrase is expected to contain an
* <code>AS</code> or <code>LIKE</code> clause.
* @param fld
* If not <code>null</code> then the given field reference will
* define a temporary scope promotion for the field's table such
* that validation expressions will resolve unambiguously.
* @param frameDef
* <code>true</code> if the caller is a statement that would create or add to a
* frame definition.
* @param enableWidget
* <code>true</code> if this format phrase is associated with a field clause which
* represents a widget being enabled in a frame; else <code>false</code>.
*/
public final void format_phrase(
String symName, Aast fld, boolean frameDef, boolean enableWidget
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast format_phrase_AST = null;
Aast h_AST = null;
Aast v_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(FORMAT_PHRASE,"format phrase"));
String baseSymName = null;
boolean matchSym = false;
boolean schem = false;
// validate processing needs a special promotion of the table because the expression can
// have otherwise ambiguous field references
if (fld != null &&
fld.getType() > BEGIN_FIELDTYPES &&
fld.getType() < END_FIELDTYPES)
{
// add a schema scope
schem = true;
sym.addSchemaScope(false);
// promote the field's associated buffer
sym.promoteTableName((String) fld.getAnnotation("bufname"), false, false);
}
{
_loop344:
do {
if ((LA(1)==KW_AT) && (_tokenSet_76.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
at_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_AS) && (LA(2)==KW_BUTTON) && (_tokenSet_3.member(LA(3))))&&( frameDef && symName != null )) {
as_button_quirk(symName);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_AS||LA(1)==KW_LIKE||LA(1)==KW_LIKE_SEQ) && (_tokenSet_81.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_AS:
{
as_clause(symName, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LIKE:
case KW_LIKE_SEQ:
{
like_clause(symName, null, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_ATTR||LA(1)==KW_NO_ATTR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_ATTR:
{
Aast tmp456_AST = null;
tmp456_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp456_AST);
match(KW_ATTR);
break;
}
case KW_NO_ATTR:
{
Aast tmp457_AST = null;
tmp457_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp457_AST);
match(KW_NO_ATTR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_AUTO_RET) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp458_AST = null;
tmp458_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp458_AST);
match(KW_AUTO_RET);
}
else if ((LA(1)==KW_BLANK) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp459_AST = null;
tmp459_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp459_AST);
match(KW_BLANK);
}
else if ((LA(1)==KW_COLON||LA(1)==KW_TO) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_COLON:
{
colon_constant();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TO:
{
to_constant();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_COL_LAB) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
column_label();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DEBLANK) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp460_AST = null;
tmp460_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp460_AST);
match(KW_DEBLANK);
}
else if ((LA(1)==KW_DIS_A_ZA) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp461_AST = null;
tmp461_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp461_AST);
match(KW_DIS_A_ZA);
}
else if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_HELP) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
help_string();
h_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LABEL||LA(1)==KW_NO_LABEL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_LABEL:
{
label(true);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_LABEL:
{
Aast tmp462_AST = null;
tmp462_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp462_AST);
match(KW_NO_LABEL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_TAB_S) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp463_AST = null;
tmp463_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp463_AST);
match(KW_NO_TAB_S);
}
else if ((LA(1)==KW_PASSWD_F) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp464_AST = null;
tmp464_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp464_AST);
match(KW_PASSWD_F);
}
else if ((LA(1)==KW_VALIDATE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
validate(schem ? (String) fld.getAnnotation("schemaname") : null);
v_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_VIEW_AS) && (_tokenSet_56.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
view_as_phrase(symName);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_WHEN) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
simple_when_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==AT) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
matchSym = (symName == null);
baseSymName=at_base_field_clause(matchSym);
astFactory.addASTChild(currentAST, returnAST);
if (matchSym && baseSymName != null)
{
symName = baseSymName;
}
}
else {
break _loop344;
}
} while (true);
}
format_phrase_AST = (Aast)currentAST.root;
// process schema-level validation for an any widget in a frame definition statement, if
// no overriding validation expression was provided. depending on USE-DICT-EXPS usage,
// all validation exps which appear before this setting (in a statement which doesn't
// enable the widget) will be removed. this is required because at this time we don't
// know the frame name - this is computed later, at the frame phrase parsing, so the
// approach is to add everything and remove as needed, depending on the USE-DICT-EXPS,
// when the frame phrase is parsed
if ((v_AST == null || h_AST == null) &&
fld != null &&
frameDef &&
!fld.isAnnotation("schema-processed"))
{
attachAssignSchemaValidation(format_phrase_AST, fld, sym);
}
if (fld != null)
{
// do not allow the field to be processed on the second pass for format_phrase (used
// by def_frame, display_stmt, form_stmt)
fld.putAnnotation("schema-processed", true);
}
// if we previously added a scope, clear it now
if (schem)
{
sym.deleteSchemaScope(false);
}
// safety first since this rule can have everything be optional
if (format_phrase_AST.getNumberOfChildren() == 0)
{
// get rid of the artificial root we previously created
format_phrase_AST = null;
}
else
{
// we only can be defining a new variable if the symbol name is
// not null
if (symName != null)
{
// pass the AST with all options to the symbol resolver to set
// those variable options accordingly
sym.setVariableOptions(symName, format_phrase_AST);
// write any non-standard options into annotations
sym.annotateVariableOptions(symName, format_phrase_AST, true);
}
}
currentAST.root = format_phrase_AST;
currentAST.child = format_phrase_AST!=null &&format_phrase_AST.getFirstChild()!=null ?
format_phrase_AST.getFirstChild() : format_phrase_AST;
currentAST.advanceChildToEnd();
format_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = format_phrase_AST;
}
/**
* Matches any number literal (<code>NUM_LITERAL</code>, <code>HEX_LITERAL</code> or a
* <code>DEC_LITERAL</code>).
*/
public final void numeric_literal() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast numeric_literal_AST = null;
Token n = null;
Aast n_AST = null;
Token h = null;
Aast h_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case NUM_LITERAL:
{
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.addASTChild(currentAST, n_AST);
match(NUM_LITERAL);
sym.annotateNumericLiteral(n_AST);
break;
}
case HEX_LITERAL:
{
h = LT(1);
h_AST = (Aast)astFactory.create(h);
astFactory.addASTChild(currentAST, h_AST);
match(HEX_LITERAL);
sym.annotateNumericLiteral(h_AST);
break;
}
case DEC_LITERAL:
{
Aast tmp465_AST = null;
tmp465_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp465_AST);
match(DEC_LITERAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = numeric_literal_AST;
}
/**
* Matches the <code>SPACE() or SKIP()</code> constructs and the optional
* following {@link #expr}. Note that although ANTLR reports ambiguity
* in the optional clause, there is no actual ambiguity so warnings have
* been disabled.
* <p>
* This is an undocumented feature of Progress which cannot be used in all
* language statements. The idea is that this construct requires runtime
* resolution of the value in the places where it is allowed.
* <p>
* Used by {@link #put_stmt}.
* <p>
* The subtree is rooted by the keyword.
*/
public final void runtime_space_or_skip() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast runtime_space_or_skip_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_SPACE:
{
Aast tmp466_AST = null;
tmp466_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp466_AST);
match(KW_SPACE);
break;
}
case KW_SKIP:
{
Aast tmp467_AST = null;
tmp467_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp467_AST);
match(KW_SKIP);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LPARENS) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
runtime_space_or_skip_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_21);
}
returnAST = runtime_space_or_skip_AST;
}
/**
* Matches the <code>NULL()</code> construct and the optional following
* integer constant. Note that although ANTLR reports ambiguity
* in the optional clause, there is no actual ambiguity so warnings have
* been disabled.
* <p>
* Used by {@link #put_stmt}.
* <p>
* The subtree is rooted by the keyword.
*/
public final void null_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast null_clause_AST = null;
try { // for error handling
Aast tmp468_AST = null;
tmp468_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp468_AST);
match(KW_NULL);
{
if ((LA(1)==LPARENS) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==RPARENS)) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
null_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_21);
}
returnAST = null_clause_AST;
}
/**
* Matches the <code>SET, UPDATE and PROMPT-FOR</code> language statements
* and implements the (nearly identical) logic for all 3.
* <p>
* This rule is called by {@link #stmt_list}.
* <p>
* Calls the following rules:
* <p>
* {@link #lvalue} (this handles the field processing AND stream references)
* {@link #space_or_skip}
* {@link #text_clause}
* {@link #at_phrase}
* {@link #to_constant}
* {@link #colon_constant} (undocumented but found in customer source)
* {@link #constant_form_item}
* {@link #record_spec}
* {@link #go_on_clause}
* {@link #frame_phrase}
* {@link #inner_block}
* <p>
* All options can be processed in any order.
* <p>
* The list of fields, records or other values to set or update is
* particularly tricky because it has very real ambiguity in allowing an
* <code>lvalue</code> in the leftmost token of 2 peer alternatives. While
* normally, a semantic predicate could be used to resolve this ambiguity,
* the <code>lvalue</code> rule itself defeats this since it supports
* array subscripting. This form of <code>lvalue</code> means that the
* <code>EQUALS</code> token (that disambiguates the assignment form from the
* <code>field_clause</code>) can appear at an arbitrary point in the token
* stream (not just in the k == 2 position). For example, myVar[ i + 7 ] =
* puts the <code>EQUALS</code> in the k == 7 position. By splitting off
* the subsequent processing and left factoring the <code>lvalue</code>,
* this problem is resolved.
* <p>
* The order of the field list/record spec alternatives is also designed to
* match more specific choices first. This combined with a semantic
* predicate to pick between a record and field, makes this work.
* <p>
* The use of <code>inner_block</code> is to implement the editing clause,
* which is a form that <code>inner_block</code> supports. This also
* matches <code>DO, REPEAT and FOR</code> keywords in addition to
* <code>EDITING</code> but this should not be a problem in practice.
* This can't be easily solved with a semantic validating rule since the
* optional label that can prefix an editing phrase makes the editing
* keyword appear in either the k == 1 or k == 3 positions. The call to
* <code>inner_block</code> uses {@link #end_stmt} to delimit the
* block. Based on how we call <code>inner_block</code>, the subsequent
* invocation of <code>end_stmt</code> does NOT eat the trailing
* <code>DOT</code> since it is called inline in this language statement.
* <p>
* Use of some other unreserved keywords naturally conflicts with possible
* following keywords, but this is a bogus ambiguity warning as Progress
* is designed to match as a keyword first. Ambiguity warnings have been
* disabled in some subrules as a result.
* <p>
* The use of the <code>constant_form_item</code> is required for the
* <code>PROMPT-FOR</code> statement and it may not be valid for the
* <code>SET or UPDATE</code> statements based on the Progress documentation.
* Valid Progress code will not have a problem with this.
* <p>
* An undocumented feature exists where in-line variable definitions are possible using an
* AS or LIKE clause in a format phrase (in all 3 forms of this rule). The AS or LIKE can
* appear later in the phrase. This was found in working customer code.
*/
public final void set_or_update_or_prompt_for_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_or_update_or_prompt_for_stmt_AST = null;
Token p = null;
Aast p_AST = null;
Aast fp_AST = null;
Aast r_AST = null;
Aast l_AST = null;
try { // for error handling
Aast fld = null;
Set<Aast> fields = new HashSet<>();
String symbolName = null;
int idx = 0;
boolean validation = false;
{
{
switch ( LA(1)) {
case KW_SET:
{
Aast tmp469_AST = null;
tmp469_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp469_AST);
match(KW_SET);
break;
}
case KW_UPDATE:
{
Aast tmp470_AST = null;
tmp470_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp470_AST);
match(KW_UPDATE);
break;
}
case KW_PRMT_FOR:
{
Aast tmp471_AST = null;
tmp471_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp471_AST);
match(KW_PRMT_FOR);
break;
}
case KW_PROMPT:
{
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(KW_PROMPT);
p_AST.setType(KW_PRMT_FOR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop313:
do {
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_UNL_HID) && (_tokenSet_82.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp472_AST = null;
tmp472_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp472_AST);
match(KW_UNL_HID);
}
else if ((LA(1)==CARET)) {
Aast tmp473_AST = null;
tmp473_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp473_AST);
match(CARET);
idx++;
}
else if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_82.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
idx++;
}
else if ((LA(1)==KW_TEXT) && (LA(2)==LPARENS) && (_tokenSet_64.member(LA(3)))) {
text_clause();
astFactory.addASTChild(currentAST, returnAST);
idx++;
}
else if ((_tokenSet_65.member(LA(1))) && (_tokenSet_82.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
literal();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_AT||LA(1)==KW_COLON||LA(1)==KW_TO) && (_tokenSet_76.member(LA(2))) && (_tokenSet_82.member(LA(3)))) {
literal_format_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_82.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
idx++;
}
else if ((LA(1)==KW_NO_ERROR) && (_tokenSet_82.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp474_AST = null;
tmp474_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp474_AST);
match(KW_NO_ERROR);
idx++;
}
else if ((LA(1)==KW_GO_ON) && (LA(2)==LPARENS) && (_tokenSet_83.member(LA(3)))) {
go_on_clause();
astFactory.addASTChild(currentAST, returnAST);
idx++;
}
else if ((LA(1)==KW_WITH) && (_tokenSet_84.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
frame_phrase(false, true);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
idx++;
}
else if (((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&(
LA(1) == KW_EDITING ||
(LA(2) == COLON && followedByWhitespace(LT(2))) ||
isMalformedLabel(true, 1, null)
)) {
Aast malformedLabel = null;
// not a proper label, check for a malformed label
boolean mal = isMalformedLabel(true, 1, null);
// HARD CODED call that can't be placed directly in our rule
// below (inner_block) without very bad results on prediction
// logic generation
if (mal)
{
malformed_symbol();
malformedLabel = (Aast)returnAST;
colon();
}
inner_block(false, malformedLabel);
astFactory.addASTChild(currentAST, returnAST);
idx++;
}
else if (((_tokenSet_13.member(LA(1))) && (_tokenSet_82.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
idx == 0 &&
isRecord(LT(1).getText()) &&
(LA(2) == KW_EXCEPT || LA(2) == KW_WITH || LA(2) == KW_NO_ERROR || LA(2) == DOT)
)) {
record_spec(fields);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
validation = true;
}
else if ((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
allowSymbolMatch = true;
chained_object_members();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
idx++;
// reset each loop iteration
symbolName = null;
fld = null;
if (l_AST.getType() == SYMBOL)
{
symbolName = l_AST.getText();
}
else
{
fld = findFieldNode(l_AST);
if (fld != null)
{
fields.add(fld);
}
}
allowSymbolMatch = false;
{
if ((LA(1)==EQUALS)) {
embedded_assign();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_86.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_phrase(symbolName, fld, true, true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_82.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop313;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
set_or_update_or_prompt_for_stmt_AST = (Aast)currentAST.root;
String frame = getFrameName(fp_AST);
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
if (validation)
{
boolean addfp = false;
if (fp_AST == null)
{
fp_AST = (Aast)astFactory.create(FRAME_PHRASE,"");
addfp = true;
}
attachAllAssignSchemaValidation(fp_AST, r_AST, sym, null);
if (addfp && fp_AST.getNumImmediateChildren() > 0)
{
set_or_update_or_prompt_for_stmt_AST.addChild(fp_AST);
}
}
setUseDictExps(frame, fp_AST, set_or_update_or_prompt_for_stmt_AST);
set_or_update_or_prompt_for_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = set_or_update_or_prompt_for_stmt_AST;
}
/**
* Matches the <code>TEXT</code> keyword and an following field specification.
* Calls the {@link #field_clause} rule.
* <p>
* Used by {@link #enable_stmt}.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void text_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast text_clause_AST = null;
try { // for error handling
Aast tmp475_AST = null;
tmp475_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp475_AST);
match(KW_TEXT);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
int _cnt945=0;
_loop945:
do {
if ((_tokenSet_64.member(LA(1)))) {
field_clause(false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt945>=1 ) { break _loop945; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt945++;
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
text_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_82);
}
returnAST = text_clause_AST;
}
/**
* Matches the format phrase construct of the Progress 4GL language which
* optionally appears following a literal in a referencing rule but does not
* begin with a specific keyword. Only a small subset of the standard
* options can be specified (see {@link #format_phrase}).
* <p>
* The following list of rules are called to properly implement the tree
* building (which will be rooted at a <code>FORMAT_PHRASE</code> token):
* <p>
* <ul>
* <li> {@link #at_phrase}
* <li> {@link #colon_constant}
* <li> {@link #to_constant}
* </ul>
* <p>
* Called from {@link #set_or_update_or_prompt_for_stmt}.
*/
public final void literal_format_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast literal_format_phrase_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(FORMAT_PHRASE,"format phrase"));
{
switch ( LA(1)) {
case KW_AT:
{
at_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_COLON:
{
colon_constant();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TO:
{
to_constant();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
literal_format_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_82);
}
returnAST = literal_format_phrase_AST;
}
/**
* Matches the <code>GO-ON()</code> construct and the list of key labels that follow in enclosing
* parenthesis. Each key label is any token at all with the loop ending on an
* <code>RPARENS</code>. Please note that the Progress documentation states that these must be
* whitespace separated and NOT comma separated. This is INCORRECT. As an undocumented feature,
* one can mix or match whitespace and/or commas to separate event entries. This rule supports
* this fully.
* <p>
* For certain event definitions such a CTRL-@, the lexer code will initially match on 2 or more
* tokens (in this case a SYMBOL (CTRL-) and an AT (@)). These are then merged using
* <code>mergeUntilWS()</code> so that the result is correct. The AST node is set to EVENT.
* <p>
* Used by {@link #set_or_update_or_prompt_for_stmt} and {@link #choose_stmt}.
* <p>
* The subtree is rooted by the keyword.
*/
public final void go_on_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast go_on_clause_AST = null;
Token e = null;
Aast e_AST = null;
try { // for error handling
Aast tmp476_AST = null;
tmp476_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp476_AST);
match(KW_GO_ON);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
int _cnt335=0;
_loop335:
do {
if ((_tokenSet_83.member(LA(1)))) {
// DOT and EOF are hard coded in the worker routine
int[] exclude = new int[]
{
COMMA,
RPARENS
};
mergeUntilWS(exclude);
e = LT(1);
e_AST = (Aast)astFactory.create(e);
astFactory.addASTChild(currentAST, e_AST);
matchNot(RPARENS);
// convert the Progress string to a Java string if needed
if (e_AST.getType() == STRING)
{
saveAndReplaceText(e_AST, character.progressToJavaString(e_AST.getText(), !unixEscapes, false));
}
// set the event type
saveAndReplaceType(e_AST, EVENT);
{
if ((LA(1)==COMMA) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
comma();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= DOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
if ( _cnt335>=1 ) { break _loop335; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt335++;
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
go_on_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_82);
}
returnAST = go_on_clause_AST;
}
/**
* Implements the 9th precedence level of Progress 4GL expressions, the chaining of object
* and handle references. A {@link #primary_expr} is always matched as the first component. If
* the node(s) from the primary expression are an object reference (a reference to a Progress
* user defined type/OO 4GL class) OR if the node(s) are a HANDLE or COM-HANDLE type, then the
* code checks for a following <code>COLON</code> operator without any following white space.
* Under these conditions, one of the {@link #downstream_chained_reference} (for OO 4GL refs),
* {@link #com_property_or_method} (COM-HANDLE refs) or {@link #attribute_or_method} (anything
* else) will be called.
* <p>
* This rule enables chaining of these constructs on a completely mix and match basis which can
* continue indefinitely so long as the most recently returned node is an object, com-handle or
* handle reference and there is a following <code>COLON</code> without any following white
* space.
* <p>
* If the preceding node is an object type, the exact fully qualified class name being referenced
* is read from the "qualified" annotation in the node. That class name is used to resolve the
* method or data member being referenced via chaining. The rule
* {@link #downstream_chained_reference} provides the matching logic for both of those cases,
* but the chaining itself is done here. The operator used for chaining is a <code>COLON</code>
* but this will be converted to an <code>OBJECT_INVOCATION</code> before return.
* <p>
* If the given node is a COM-HANDLE type, if it is then the rule {@link #com_property_or_method}
* provides the matching logic but the downstream chaining itself is done here. The operator used
* for chaining is a <code>COLON</code> but this will be converted to a
* <code>COM_INVOCATION</code> before return.
* <p>
* Supports the <code>DB_REF_NON_STATIC</code> operator. This is the syntax added in 10.2x which
* allows a database table name or table + field name to be directly referenced off a handle using
* the <code>::</code> operator. This includes chaining support and mix/match chaining.
* <p>
* This is only called by the 7th level {@link #un_type} rule.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
*/
public final void chained_object_members() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast chained_object_members_AST = null;
Aast pe_AST = null;
Token col = null;
Aast col_AST = null;
Aast dr_AST = null;
Aast am_AST = null;
try { // for error handling
boolean active_x = false;
boolean object = false;
boolean isStatic = false;
String cls = null;
Aast refnode = null;
boolean saveMatchAssign = matchAssign;
matchAssign = false;
primary_expr();
pe_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
refnode = pe_AST;
boolean classLookup = sym.isClassLookup();
sym.setClassLookup(false);
{
_loop1682:
do {
if (((LA(1)==COLON) && (_tokenSet_87.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !followedByWhitespace(LT(1)) )) {
col = LT(1);
col_AST = (Aast)astFactory.create(col);
astFactory.makeASTRoot(currentAST, col_AST);
match(COLON);
if (refnode == null)
{
throw genExc("Missing refnode for COLON operator!", LT(1));
}
// COM-HANDLE reference (or possible reference)
active_x = isComHandleType(refnode);
// determine if the primary expression is an object or class reference
object = isObjectSubtree(refnode);
if (object)
{
sym.setClassLookup(true);
isStatic = isStaticObject(refnode);
// determine to what specific class that reference refers
cls = getObjectClassName(refnode);
}
{
if (((_tokenSet_88.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( object )) {
boolean isSuper = refnode.getType() == VAR_CLASS &&
refnode.isAnnotation("oldtype") &&
(Long) refnode.getAnnotation("oldtype") == KW_SUPER;
downstream_chained_reference(cls, isStatic, isSuper);
dr_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
col_AST.setType(OBJECT_INVOCATION);
testAndSaveGenericType(refnode, dr_AST);
if (dr_AST.isAnnotation("dotnet-enum-implicit-value") &&
(boolean) dr_AST.getAnnotation("dotnet-enum-implicit-value"))
{
if (refnode.isAnnotation("tempidx"))
{
long idx = (long) refnode.getAnnotation("tempidx");
// override the previous tempidx (which does not point to any definition since
// this variable is implicit; we must point to the specific enum being referenced
dr_AST.putAnnotation("tempidx", idx);
}
else
{
System.out.printf("MISSING TEMPIDX for implicit value__ reference. %s\n",
col_AST.dumpTree());
}
}
refnode = dr_AST;
}
else if (((_tokenSet_89.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( active_x )) {
com_property_or_method();
astFactory.addASTChild(currentAST, returnAST);
col_AST.setType(COM_INVOCATION);
}
else if ((_tokenSet_90.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
attribute_or_method();
am_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
refnode = am_AST;
{
if (((LA(1)==KW_IN) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!inDynFunc &&
(LA(2) == KW_FRAME || LA(2) == KW_MENU || LA(2) == KW_SUB_MENU || LA(2) == KW_BROWSE)
)) {
widget_qualifier();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((LA(1)==DB_REF_NON_STATIC) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
{
Aast tmp477_AST = null;
tmp477_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp477_AST);
match(DB_REF_NON_STATIC);
malformed_symbol();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==LPARENS) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
lparens_subscript();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==DB_REF_NON_STATIC) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
{
Aast tmp478_AST = null;
tmp478_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp478_AST);
match(DB_REF_NON_STATIC);
malformed_symbol();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==LPARENS) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
lparens_subscript();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop1682;
}
} while (true);
}
sym.setClassLookup(classLookup);
matchAssign = saveMatchAssign;
chained_object_members_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = chained_object_members_AST;
}
/**
* Matches an <code>EQUALS</code> token (the equals sign) and a following
* {@link #expr}. The token type of the <code>EQUALS</code> is changed to
* <code>ASSIGN</code> and the construct is rooted on that token.
* <p>
* Used by {@link #entry_stmt} and {@link #compile_stmt}.
*/
public final void embedded_assign() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast embedded_assign_AST = null;
Token eq = null;
Aast eq_AST = null;
try { // for error handling
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(EQUALS);
eq_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
embedded_assign_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_82);
}
returnAST = embedded_assign_AST;
}
/**
* Matches the <code>INSERT</code> language statement. Uses the
* {@link #record_spec}, {@link #using_id_clause} and
* {@link #frame_phrase} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void insert_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast insert_stmt_AST = null;
Aast r_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
Aast tmp479_AST = null;
tmp479_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp479_AST);
match(KW_INSERT);
record_spec(fields);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_USING:
{
using_id_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
case KW_WITH:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp480_AST = null;
tmp480_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp480_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
insert_stmt_AST = (Aast)currentAST.root;
String frame = getFrameName(fp_AST);
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
boolean addfp = false;
if (fp_AST == null)
{
fp_AST = (Aast)astFactory.create(FRAME_PHRASE,"");
addfp = true;
}
attachAllAssignSchemaValidation(fp_AST, r_AST, sym, null);
if (addfp && fp_AST.getNumImmediateChildren() > 0)
{
insert_stmt_AST.addChild(fp_AST);
}
setUseDictExps(frame, fp_AST, insert_stmt_AST);
insert_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = insert_stmt_AST;
}
/**
* Matches the <code>USING</code> keyword and the following
* <code>RECID or ROWID</code> construct as encoded by
* {@link #recid_or_rowid}. Called by {@link #create_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void using_id_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast using_id_clause_AST = null;
try { // for error handling
Aast tmp481_AST = null;
tmp481_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp481_AST);
match(KW_USING);
recid_or_rowid();
astFactory.addASTChild(currentAST, returnAST);
using_id_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_91);
}
returnAST = using_id_clause_AST;
}
/**
* Matches the <code>RAW</code> language statement with the following
* {@link #lvalue} and 1 or 2 optional integer {@link #expr} for position
* and length.
* <p>
* Called by {@link #assign_type_syntax_stmt_list}.
* The call is commented because the this statement is processed via the func_call, and after that fixed in
* restoreAssignStyleStmt.
*/
public final void raw_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast raw_stmt_AST = null;
try { // for error handling
Aast tmp482_AST = null;
tmp482_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp482_AST);
match(KW_RAW);
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
raw_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = raw_stmt_AST;
}
/**
* Matches the <code>SET-SIZE</code> language statement with the following
* {@link #lvalue}.
* <p>
* Called by {@link #assign_type_syntax_stmt_list}.
*/
public final void set_size_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_size_stmt_AST = null;
try { // for error handling
Aast tmp483_AST = null;
tmp483_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp483_AST);
match(KW_SET_SZ);
lparens();
astFactory.addASTChild(currentAST, returnAST);
chained_object_members();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
set_size_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = set_size_stmt_AST;
}
/**
* Matches the <code>SET-BYTE-ORDER</code> language statement with the
* following {@link #lvalue}.
* <p>
* Called by {@link #assign_type_syntax_stmt_list}.
*/
public final void set_byte_order_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_byte_order_stmt_AST = null;
try { // for error handling
Aast tmp484_AST = null;
tmp484_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp484_AST);
match(KW_SET_B_OR);
lparens();
astFactory.addASTChild(currentAST, returnAST);
chained_object_members();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
set_byte_order_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = set_byte_order_stmt_AST;
}
/**
* Matches the <code>SET-POINTER-VALUE</code> language statement with the
* following {@link #lvalue}.
* <p>
* Called by {@link #assign_type_syntax_stmt_list}.
*/
public final void set_pointer_value_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_pointer_value_stmt_AST = null;
try { // for error handling
Aast tmp485_AST = null;
tmp485_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp485_AST);
match(KW_SET_PTR);
lparens();
astFactory.addASTChild(currentAST, returnAST);
chained_object_members();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
set_pointer_value_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = set_pointer_value_stmt_AST;
}
/**
* Matches the <code>PUT-BITS, PUT-BYTE, PUT-BYTES, PUT-DOUBLE,</code>
* <code>PUT-FLOAT, PUT-INT64, PUT-LONG, PUT-SHORT, PUT-STRING,</code>
* <code>PUT-UNSIGNED-LONG, PUT-UNSIGNED-SHORT</code> language statement
* with the following {@link #expr} expressions.
* <p>
* Most of these statements are specific to the <code>MEMPTR</code> data type
* but not all (contrary to what the name of this rule might suggest. The
* format is essentially identical, so they were all collapsed into this
* single rule.
* <p>
* Called by {@link #assign_type_syntax_stmt_list}.
*/
public final void put_memptr_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast put_memptr_stmt_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_PUT_BITS:
{
Aast tmp486_AST = null;
tmp486_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp486_AST);
match(KW_PUT_BITS);
break;
}
case KW_PUT_BYTE:
{
Aast tmp487_AST = null;
tmp487_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp487_AST);
match(KW_PUT_BYTE);
break;
}
case KW_PUT_BYTS:
{
Aast tmp488_AST = null;
tmp488_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp488_AST);
match(KW_PUT_BYTS);
break;
}
case KW_PUT_DBL:
{
Aast tmp489_AST = null;
tmp489_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp489_AST);
match(KW_PUT_DBL);
break;
}
case KW_PUT_FLT:
{
Aast tmp490_AST = null;
tmp490_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp490_AST);
match(KW_PUT_FLT);
break;
}
case KW_PUT_I64:
{
Aast tmp491_AST = null;
tmp491_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp491_AST);
match(KW_PUT_I64);
break;
}
case KW_PUT_LONG:
{
Aast tmp492_AST = null;
tmp492_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp492_AST);
match(KW_PUT_LONG);
break;
}
case KW_PUT_SHT:
{
Aast tmp493_AST = null;
tmp493_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp493_AST);
match(KW_PUT_SHT);
break;
}
case KW_PUT_STR:
{
Aast tmp494_AST = null;
tmp494_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp494_AST);
match(KW_PUT_STR);
break;
}
case KW_PUT_UL:
{
Aast tmp495_AST = null;
tmp495_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp495_AST);
match(KW_PUT_UL);
break;
}
case KW_PUT_USHT:
{
Aast tmp496_AST = null;
tmp496_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp496_AST);
match(KW_PUT_USHT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
put_memptr_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = put_memptr_stmt_AST;
}
/**
* Matches the <code>NEXT-PROMPT</code> language statement. Uses the {@link #lvalue} and
* {@link #frame_phrase} rules. Undocumented support has been added for optional
* <code>INPUT</code> and <code>FRAME framename</code> qualifiers before the lvalue. This
* was working syntax that was found in customer source code.
* <p>
* The 4GL has an undocumented feature that allows a {@link #format_phrase} to be specified
* after the lvalue. This is implemented here.
* <p>
* Used by {@link #stmt_list}.
*/
public final void next_prompt_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast next_prompt_stmt_AST = null;
Token in = null;
Aast in_AST = null;
Aast l_AST = null;
Aast fp_AST = null;
try { // for error handling
Aast tmp497_AST = null;
tmp497_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp497_AST);
match(KW_NEXT_PMT);
{
if ((LA(1)==KW_INPUT)) {
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INPUT);
hide(in);
}
else if ((_tokenSet_64.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_FRAME) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
frame_reference(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_92.member(LA(1))) && (_tokenSet_93.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_phrase(null, null, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_WITH) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
int type = l_AST.getType();
if (type > BEGIN_FIELDTYPES && type < END_FIELDTYPES)
{
String frameName = getFrameName(fp_AST);
sym.addFrameField(frameName, l_AST);
}
next_prompt_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = next_prompt_stmt_AST;
}
/**
* Matches the <code>FRAME frame</code> reference seen in many Progress
* language statements such as {@link #clear_stmt} and the common
* {@link #frame_phrase}.
* <p>
* If the single parameter is true, the frame is added to the frame namespace.
* In any case, the following {@link #symbol} is rewritten to a
* <code>WID_FRAME</code> token.
* <p>
* This rule is a simplified version of what can also be accessed directly
* from {@link #lvalue} but this keeps certain references much less
* ambiguous.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* <code>FRAME</code> keyword.
*/
public final void frame_reference(
boolean define
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast frame_reference_AST = null;
Aast frame_AST = null;
try { // for error handling
Aast tmp498_AST = null;
tmp498_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp498_AST);
match(KW_FRAME);
malformed_symbol();
frame_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
frame_AST.setType(WID_FRAME);
if (define)
{
sym.addFrame(frame_AST.getText(), WID_FRAME);
}
frame_reference_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = frame_reference_AST;
}
/**
* This rule implements the at-phrase construct. It is called from
* {@link #frame_phrase} and {@link #form_item} rules.
* <p>
* This rule defines the AT phrase of Progress 4GL. The definition here is
* less strict than in 4GL, but for the sake of parsing a valid 4GL source it
* is adequate.
* <p>
* Ambiguity warnings were generated in the {@link #def_frame_stmt} and in
* this rule because the optional alignment nonreserved keywords conflicted
* with the symbols in the frame definition.
* As far as can be found, there is no real ambiguity in practice and
* those rules have hade ambiguity warning suppressed as a result.
*/
public final void at_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast at_phrase_AST = null;
try { // for error handling
Aast tmp499_AST = null;
tmp499_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp499_AST);
match(KW_AT);
{
switch ( LA(1)) {
case KW_COLUMNS:
case KW_COL:
case KW_COL_OF:
case KW_ROW:
case KW_ROW_OF:
case KW_X:
case KW_X_OF:
case KW_Y:
case KW_Y_OF:
{
location_spec();
astFactory.addASTChild(currentAST, returnAST);
location_spec();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_COLON_AL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp500_AST = null;
tmp500_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp500_AST);
match(KW_COLON_AL);
}
else if ((LA(1)==KW_LEFT_AL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp501_AST = null;
tmp501_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp501_AST);
match(KW_LEFT_AL);
}
else if ((LA(1)==KW_RIGHT_AL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp502_AST = null;
tmp502_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp502_AST);
match(KW_RIGHT_AL);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case DEC_LITERAL:
case HEX_LITERAL:
case NUM_LITERAL:
{
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
at_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = at_phrase_AST;
}
/**
* Matches a specific <code>COLON literal</code> clause used in the
* {@link #format_phrase}.
* <p>
* Separated from the main rule to properly build the AST with less effort.
* This is the only reason such a simple rule is implemented separately.
*/
public final void colon_constant() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast colon_constant_AST = null;
try { // for error handling
Aast tmp503_AST = null;
tmp503_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp503_AST);
match(KW_COLON);
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
colon_constant_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = colon_constant_AST;
}
/**
* Matches a specific <code>TO literal</code> clause used in the
* {@link #constant_form_item} and {@link #format_phrase}.
* <p>
* Separated from the main rule to properly build the AST with less effort.
* This is the only reason such a simple rule is implemented separately.
*/
public final void to_constant() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast to_constant_AST = null;
try { // for error handling
Aast tmp504_AST = null;
tmp504_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp504_AST);
match(KW_TO);
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
to_constant_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = to_constant_AST;
}
/**
* Matches an <code>AS BUTTON</code> clause and adds a button widget as if an inline
* <code>DEFINE BUTTON</code> had been implemented. This is an undocumented quirk of the
* {@link #format_phrase}. The root node will be of type <code>AS_BUTTON</code>.
*
* @param symName
* The name of the new button. Must not be <code>null</code>.
*/
public final void as_button_quirk(
String symName
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast as_button_quirk_AST = null;
Token a = null;
Aast a_AST = null;
Token but = null;
Aast but_AST = null;
try { // for error handling
a = LT(1);
a_AST = (Aast)astFactory.create(a);
astFactory.makeASTRoot(currentAST, a_AST);
match(KW_AS);
but = LT(1);
but_AST = (Aast)astFactory.create(but);
match(KW_BUTTON);
hide(but);
a_AST.setType(AS_BUTTON);
sym.addWidget(symName, WID_BUTTON);
as_button_quirk_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = as_button_quirk_AST;
}
/**
* Matches the <code>AS</code> language keyword that defines the data type
* of a variable to be added to the variable dictionary. This rule
* encapsulates the logic of matching the correct variable data type and
* inserting it into the variable dictionary in the correct scope. This is
* called from {@link #def_var_stmt} and {@link #parameter}, both of which
* support the same syntax. It is also called from {@link #def_parm_stmt}
* which does allow for an optional <code>HANDLE TO</code> construct when being
* called for a <code>DEFINE PARAMETER</code>.
* <p>
* The data type matching is implemented in {@link #var_type}.
*
* @param varName
* Text which is the variable name that should be added to the
* current scope of the variable dictionary. If <code>null</code>,
* no name will be added and this clause is essentially ignored.
* @param nativeTypes
* <code>true</code> to support extra type keywords for native
* shared library interfaces.
*/
public final void as_clause(
String varName, boolean nativeTypes
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast as_clause_AST = null;
Token ht = null;
Aast ht_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
Aast tmp505_AST = null;
tmp505_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp505_AST);
match(KW_AS);
{
if (((LA(1)==KW_HANDLE) && (LA(2)==KW_TO) && (_tokenSet_0.member(LA(3))))&&( (nativeTypes && (LA(3) != NUM_LITERAL || LA(3) != HEX_LITERAL)) )) {
ht = LT(1);
ht_AST = (Aast)astFactory.create(ht);
astFactory.addASTChild(currentAST, ht_AST);
match(KW_HANDLE);
ht_AST.setType(HANDLE_TO);
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
var_type( varName, nativeTypes );
astFactory.addASTChild(currentAST, returnAST);
// move the HANDLE_TO node to be the last child, since otherwise the downstream
// tree processing will have to have many extra checks and conditional logic to
// deal with this rare case (the common case is to just have a single child that
// specifies the type)
if (ht_AST != null)
{
ht_AST.move(null, -1);
}
as_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = as_clause_AST;
}
/**
* Matches the <code>LIKE</code> language keyword that defines the data type
* of a variable to be added to the variable dictionary based on the type of
* another variable, database field, temp-table/work-table field. This rule
* encapsulates the logic of matching the correct data type and inserting it
* into the proper dictionary. This is called from many locations (see below)
* which all handle the same syntax but for different purposes. This allows
* the matching logic to be centralized and reused from multiple callers.
* <p>
* If this is processing for a temp-table, then instead of <code>LIKE</code> the
* <code>LIKE-SEQUENTIAL</code> keyword can be matched instead.
* <p>
* To know what to do with each different type of dictionary add, this rule
* requires 3 parameters. The 1st is the is the variable, field or table
* name to be added to the dictionary. This is necessary since there is no
* way to implement a standard match for the symbol name from all language
* statements that call this rule.
* <p>
* A 2nd parameter is <code>null</code> if this is a variable dictionary
* add or it is an Object that represents a table in the schema dictionary
* in which to add fields.
* <p>
* A 3rd parameter provides the context of the type of symbol to be looked
* up. This is a simple boolean value that indicates if the name is a table
* or a variable/field. This context is known by the referencing rule and it
* eliminates any ambiguity regarding the type of lookup.
* <p>
* Locations from which this rule is referenced:
* <ul>
* <li> as a variable or field (lvalue)
* <ul>
* <li> {@link #def_var_stmt}
* <li> {@link #def_parm_stmt}
* <li> {@link #format_phrase}
* </ul>
* <li> as a table name
* <ul>
* <li> {@link #def_temp_table_stmt} (for temp-tables and
* work-tables)
* </ul>
* <li> as a field name to be added to a temp-table or work-table
* <ul>
* <li> {@link #add_temp_table_field}
* </ul>
* </ul>
* <p>
* The 2nd token found must be a valid name from the schema or as defined by
* previous statements. The corresponding token type is then used to set the
* proper variable data type or to obtain the temp-table/work-table name.
* For variables and fields, the type is returned by the {@link #lvalue} rule
* which handles field level lookups. For table names the {@link #record}
* rule is used.
* <p>
* In temp-table and work-table adds, there is optional matching that is
* additionally enabled by semantic predicate. This matching is done in
* the {@link #temp_table_use_index} rule.
* <p>
* Note that this rule DOES support the addition of scoped shared and global
* shared variables. No special steps are necessary to enable this due to
* a quirk in how Progress handles such variables, they can only be defined
* in the top-level context (not inside a procedure or function which is the
* only block in which there is a different scoping level). For this reason,
* whenever shared variables are added to the dictionary, they can be added
* to the current scope, since this is the same as the global scope in any
* valid Progress code.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*
* @param symName
* Text which is the variable, temp-table or work-table name that
* should be added to the current scope of the respective
* dictionary. If <code>null</code>, no name will be added and this
* clause is essentially ignored.
* @param table
* A reference to a table previously added to the dictionary. Must
* be <code>null</code> if this is a modification of the variable
* namespace.
* @param tablename
* If true, the name is to be interpreted as a tablename, otherwise
* the name is an lvalue (variable or field name).
*/
public final void like_clause(
String symName, Object table, boolean tablename
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast like_clause_AST = null;
Aast l_AST = null;
Aast r_AST = null;
Token kv = null;
Aast kv_AST = null;
try { // for error handling
boolean hasValidate = false;
boolean sequential = false;
Aast field = null;
Aast[] tableFields = null;
NameNode nothing = null;
{
if (((LA(1)==KW_LIKE_SEQ))&&( tablename )) {
Aast tmp506_AST = null;
tmp506_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp506_AST);
match(KW_LIKE_SEQ);
sequential = true;
}
else if ((LA(1)==KW_LIKE)) {
Aast tmp507_AST = null;
tmp507_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp507_AST);
match(KW_LIKE);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
inLikeClause = true;
{
if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !tablename )) {
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
nothing=record(false, false, false);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
// this block is not an exit action, but does need to be executed
// before the matching on temp_table_use_index
// this is only needed in lvalue annotations and subscript
// processing (called from lvalue) so it can be "turned off" here
inLikeClause = false;
if (symName != null)
{
if (table != null)
{
if (tablename)
{
// this is a "like table" form, so add all the fields
// from the referenced table into the target table
if (r_AST != null)
{
tableFields = sym.addFieldsFrom(table,
r_AST.getText(),
false,
sequential,
true);
}
else
{
LOG.log(Level.SEVERE, "Missing required record for adding "
+ "'all fields from' table.");
}
}
else
{
// this is a field to be added to a specific table def
// (temp-table or work-table)
if (l_AST != null)
{
field = sym.addFieldLike(table, symName, l_AST);
}
else
{
String errtxt = "Missing required lvalue for adding " +
symName +
" field to table.";
LOG.log(Level.SEVERE, errtxt);
}
}
// this works as long as this code is only called by things
// like def_temp_table_stmt which is true at this time
sym.promoteTable(table, true, false, false);
}
else
{
// here is where we enable the variable lookup for all
// subsquent code in this scope, note that Progress only seems
// to ever have 2 levels of scope: the external proc and any
// internal proc/trigger defs, since you can only define shared
// or global shared vars in the external proc scope, we should
// *not* need to explicitly add vars to the global scope since
// adding to the current scope should be equivalent
if (l_AST != null)
{
sym.addLocalVariableLike(symName, l_AST);
}
else
{
LOG.log(Level.SEVERE, "Missing required lvalue for adding " +
symName +
" to local variable dictionary.");
}
}
}
{
_loop1117:
do {
if (((LA(1)==KW_VALIDATE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( table != null )) {
kv = LT(1);
kv_AST = (Aast)astFactory.create(kv);
astFactory.addASTChild(currentAST, kv_AST);
match(KW_VALIDATE);
// TODO: do we need to record anything special in the field case?
if (tablename)
sym.setTableOption(table, KW_VALIDATE, kv_AST);
hasValidate = true;
}
else if (((LA(1)==KW_USE_IDX) && (_tokenSet_53.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( tablename )) {
temp_table_use_index(table);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1117;
}
} while (true);
}
if (field != null)
{
String sourceSchemaName = (String) l_AST.getAnnotation("schemaname");
sym.processLikeField(field, hasValidate, sourceSchemaName);
}
if (tableFields != null)
{
String sourceSchemaName = (String) r_AST.getAnnotation("schemaname");
for (int i = 0; i < tableFields.length; i++)
{
Aast child = tableFields[i];
String schemaName = sourceSchemaName + "." + child.getText();
sym.processLikeField(child, hasValidate, schemaName);
}
if (sequential)
{
sym.setTableOption(table, KW_LIKE_SEQ, r_AST);
}
}
like_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = like_clause_AST;
}
/**
* Matches the <code>COLUMN-LABEL</code> keyword and the required following
* string. Used by {@link #def_var_stmt} and the subtree is rooted by the
* keyword (which is the reason for using a separate rule for something so
* simple).
*/
public final void column_label() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast column_label_AST = null;
try { // for error handling
Aast tmp508_AST = null;
tmp508_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp508_AST);
match(KW_COL_LAB);
Aast tmp509_AST = null;
tmp509_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp509_AST);
match(STRING);
column_label_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = column_label_AST;
}
/**
* Matches the <code>FORMAT</code> keyword and the required following
* string. Used by {@link #def_var_stmt} and {@link #format_phrase} rules.
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
* <p>
* Customer code has shown that Progress allows unquoted format 'strings'
* to be used here. For example 99/99/9999 instead of '99/99/9999'! This
* means that we must use {@link #expr} instead of <code>STRING</code>
* AND that this trick of using an expression may fail if their tolerance
* for such ambiguous and arbitrary constructs is great. For example,
* if one were to code x(25) instead of 'x(25)', this would start to be
* quite a problem since this would parse as a function call to a function
* 'x' which probably doesn't exist and even if it did, it would be the
* wrong tokens since we really should have a single required string token
* following the <code>FORMAT</code> keyword.
* <p>
* To make this better, the exit action converts any non-quoted format to
* a <code>STRING</code> node with the proper quoting.
* <p>
* It might be useful to merge this with {@link #ui_stuff} since both rules
* have identical structure and they are <b><code>almost always</code> referenced
* as peer alternatives. However, there are a few places where this rule
* is referenced without the other so this would add ambiguity where none
* exists today. More importantly, the risk associated with changes
* to this rule (because of the ridiculous ambiguity described above) means
* it is safer to leave this separate so that changes can be made here as
* needed.</b>
*
* @param dynExpr
* flag indicating the format string can be any dynamic expression.
*/
public final void format_string(
boolean dynExpr
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast format_string_AST = null;
Aast e_AST = null;
try { // for error handling
Aast tmp510_AST = null;
tmp510_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp510_AST);
match(KW_FORMAT);
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
Aast child = e_AST.getChildAt(0);
if (child == null)
{
LOG.log(Level.SEVERE, e_AST.dumpTree());
}
// convert any non-quoted format to a valid string
if (!dynExpr && child.getType() != STRING)
{
saveAndReplaceTypeAndText(child, STRING, '"' + child.getText() + '"');
}
format_string_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = format_string_AST;
}
/**
* Matches the <code>HELP</code> keyword and the required following
* string. Used by {@link #format_phrase} and the subtree is rooted by the
* keyword (which is the reason for using a separate rule for something so
* simple).
*/
public final void help_string() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast help_string_AST = null;
try { // for error handling
Aast tmp511_AST = null;
tmp511_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp511_AST);
match(KW_HELP);
Aast tmp512_AST = null;
tmp512_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp512_AST);
match(STRING);
help_string_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = help_string_AST;
}
/**
* Matches the <code>VALIDATE( expression )</code> construct which specifies
* a boolean condition expression and a message string expression to display
* when the condition expression evaluates to false.
* <p>
* Used by {@link #format_phrase}.
* <p>
* Separating this allows the AST to be built cleanly and also centralizes
* the logic for reuse.
*
* @param schemaName
* The schema name of the field being validated (may be null).
*/
public final void validate(
String schemaName
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast validate_AST = null;
try { // for error handling
validation = true;
validateFieldName = schemaName;
Aast tmp513_AST = null;
tmp513_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp513_AST);
match(KW_VALIDATE);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
validation = false;
validateFieldName = null;
validate_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = validate_AST;
}
/**
* Matches the <code>VIEW-AS</code> phrase which is called from many locations
* such as {@link #def_var_stmt}. Uses the following:
* <ul>
* <li> {@link #combo_box_phrase}
* <li> {@link #simple_widget_phrase}
* <li> {@link #editor_phrase}
* <li> {@link #radio_set_phrase}
* <li> {@link #selection_list_phrase}
* <li> {@link #slider_phrase}
* </ul>
* <p>
* All options can be specified in any order.
* <p>
* This rule updates the widget namespace with a name and type of the
* referenced symbol. For variables (when called from
* <code>def_var_stmt</code>), this means that the variable has been added to
* both namespaces. This allows the same name to be used for both a
* variable and a widget and the parser must recognize the usage by context.
*/
public final void view_as_phrase(
String symName
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast view_as_phrase_AST = null;
try { // for error handling
int ntype = -1;
Aast tmp514_AST = null;
tmp514_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp514_AST);
match(KW_VIEW_AS);
{
switch ( LA(1)) {
case KW_COMBO_BX:
{
combo_box_phrase();
astFactory.addASTChild(currentAST, returnAST);
ntype = WID_COMBO;
break;
}
case KW_TEXT:
case KW_FILL_IN:
case KW_TOGGL_BX:
{
ntype=simple_widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_EDITOR:
{
editor_phrase();
astFactory.addASTChild(currentAST, returnAST);
ntype = WID_EDITOR;
break;
}
case KW_RADIO_S:
{
radio_set_phrase();
astFactory.addASTChild(currentAST, returnAST);
ntype = WID_RADIO;
break;
}
case KW_SEL_LST:
{
selection_list_phrase();
astFactory.addASTChild(currentAST, returnAST);
ntype = WID_SEL_LST;
break;
}
case KW_SLIDER:
{
slider_phrase();
astFactory.addASTChild(currentAST, returnAST);
ntype = WID_SLIDER;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (symName != null)
sym.addWidget(symName, ntype);
view_as_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = view_as_phrase_AST;
}
/**
* Matches the <code>WHEN</code> keyword and the required following
* expression. This is a simpler form of the {@link #when_clause} which
* requires a <code>THEN</code> following construct.
* <p>
* Used by {@link #display_stmt}, {@link #assign_stmt} and
* {@link #field_clause}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void simple_when_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_when_clause_AST = null;
try { // for error handling
Aast tmp515_AST = null;
tmp515_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp515_AST);
match(KW_WHEN);
expr();
astFactory.addASTChild(currentAST, returnAST);
simple_when_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = simple_when_clause_AST;
}
/**
* Matches the <code>@</code> sign and the required following variable or
* field name (see {@link #lvalue}).
* <p>
* Used by {@link #display_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*
* @param matchSym
* <code>true</code> if this clause should allow matches to
* a <code>SYMBOL</code> node in place of the lvalue.
*
* @return The symbol name if a <code>SYMBOL</code> was matched, otherwise
* <code>null</code>.
*/
public final String at_base_field_clause(
boolean matchSym
) throws RecognitionException, TokenStreamException {
String name;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast at_base_field_clause_AST = null;
Aast base_AST = null;
name = null;
if (matchSym)
{
allowSymbolMatch = true;
}
try { // for error handling
Aast tmp516_AST = null;
tmp516_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp516_AST);
match(AT);
lvalue();
base_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (matchSym)
{
allowSymbolMatch = false;
if (base_AST.getType() == SYMBOL)
{
name = base_AST.getText();
}
}
at_base_field_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = at_base_field_clause_AST;
return name;
}
/**
* Matches the <code>BY</code> keyword and the required following expression.
* <p>
* Used by {@link #aggregate_phrase} and {@link #loop_incr} rules.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void by_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast by_clause_AST = null;
try { // for error handling
Aast tmp517_AST = null;
tmp517_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp517_AST);
match(KW_BY);
expr();
astFactory.addASTChild(currentAST, returnAST);
by_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = by_clause_AST;
}
/**
* Matches the constant prefixed subclause of the {@link #form_item}.
* Calls {@link #view_as_text_clause}, {@link #ui_stuff}, {@link #at_phrase}
* and {@link #to_constant}.
* <p>
* ANTLR detects ambiguity in the loop of this rule due to conflict between
* the unreserved keywords and the expression that follows in the 2nd token
* position for <code>ui_stuff</code>. This code should match on the
* keywords first, so these ambiguity warnings have been disabled.
* <p>
* Though undocumented, one can specify a {@link #format_string} as an
* option.
* <p>
* Separated from the main rule to properly build the AST with less effort.
* This is the only reason such a simple rule is implemented separately.
*/
public final void constant_form_item() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast constant_form_item_AST = null;
try { // for error handling
literal();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_AT:
{
at_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TO:
{
to_constant();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((_tokenSet_94.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop356:
do {
switch ( LA(1)) {
case KW_FORMAT:
{
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_VIEW_AS:
{
view_as_text_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop356;
}
}
} while (true);
}
constant_form_item_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_95);
}
returnAST = constant_form_item_AST;
}
/**
* Matches a specific <code>VIEW-AS TEXT</code> clause used in the
* {@link #constant_form_item}.
* <p>
* Separated from the main rule to properly build the AST with less effort.
* This is the only reason such a simple rule is implemented separately.
*/
public final void view_as_text_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast view_as_text_clause_AST = null;
try { // for error handling
Aast tmp518_AST = null;
tmp518_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp518_AST);
match(KW_VIEW_AS);
Aast tmp519_AST = null;
tmp519_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp519_AST);
match(KW_TEXT);
view_as_text_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_94);
}
returnAST = view_as_text_clause_AST;
}
/**
* Matches the <code>ACCUM</code> keyword and the optional following maximum
* length. This rule conflicts with the use of a <code>whole_number_literal</code>
* construct when k=1 in the calling rule {@link #frame_phrase}. To eliminate
* the ambiguity warning, ANTLR's greedy option had to be explicitly enabled.
* Since greedy is the default, this doesn't change the code generation, it
* only suppresses the warning. <b>Note that this rule checks the k=2
* lookahead before matching the <code>whole_number_literal</code>. This may be OK
* but it may also bypass the match in a case where something unexpected
* follows the <code>whole_number_literal</code>. Since this cannot be proven for all
* cases, watch this code!</b>
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void accum_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast accum_clause_AST = null;
try { // for error handling
Aast tmp520_AST = null;
tmp520_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp520_AST);
match(KW_ACCUM);
{
if ((LA(1)==HEX_LITERAL||LA(1)==NUM_LITERAL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
accum_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = accum_clause_AST;
}
/**
* Matches the <code>CANCEL-BUTTON or DEFAULT-BUTTON</code> keywords and the
* required following button name. No button namespace processing is done
* to confirm that the following symbol is indeed a button.
* <p>
* Used by {@link #frame_phrase}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void button_reference() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast button_reference_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_CANCEL_B:
{
Aast tmp521_AST = null;
tmp521_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp521_AST);
match(KW_CANCEL_B);
break;
}
case KW_DEFLT_BN:
{
Aast tmp522_AST = null;
tmp522_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp522_AST);
match(KW_DEFLT_BN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lvalue();
astFactory.addASTChild(currentAST, returnAST);
button_reference_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = button_reference_AST;
}
/**
* Matches the color_spec construct of the Progress 4GL language. Uses the {@link #color_phrase}
* rule downstream for the bulk of this rule's implementation.
* <p>
* This rule is called from {@link #title_phrase} and {@link #frame_phrase}.
* <p>
* ANTLR detects ambiguity in each loop of this rule due to conflict between
* unreserved keywords and the symbol that can be generated by the rule
* reference to <code>color_phrase</code> or the expression that follows in
* the 2nd token position for <code>ui_stuff</code>. This code should match
* on the keywords first, so these ambiguity warnings have been disabled.
*/
public final void color_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast color_spec_AST = null;
try { // for error handling
Aast tmp523_AST = null;
tmp523_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp523_AST);
match(KW_COLOR);
display_color_clause();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_PROMPT||LA(1)==KW_PRMT_FOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
prompt_color_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
color_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = color_spec_AST;
}
/**
* Matches the <code>CONTEXT-HELP-FILE</code> keyword and the required
* following {@link #filename}.
* <p>
* Used by {@link #frame_phrase}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void context_help_file() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast context_help_file_AST = null;
try { // for error handling
Aast tmp524_AST = null;
tmp524_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp524_AST);
match(KW_CTX_H_F);
filename(null);
astFactory.addASTChild(currentAST, returnAST);
context_help_file_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = context_help_file_AST;
}
/**
* Matches the title-phrase construct of the Progress 4GL language. This implementation uses
* {@link #simple_color_clause} (for the {@code COLOR color_phrase} and {@link #ui_stuff} for
* {@code FONT expr}, {@code BGCOLOR expr}, {@code DCOLOR expr} and {@code FGCOLOR expr}
* constructs that can occur just before the title string expression.
* <p>
* This rule is called from {@link #frame_phrase} and {@link #browse_options_phrase} rules.
* <p>
* ANTLR detects ambiguity in the use of <code>ui_stuff</code> and <code>color_spec</code>.
* The code has been protected with semantic predicates and ambiguity warnings have been
* disabled.
*/
public final void title_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast title_phrase_AST = null;
try { // for error handling
Aast tmp525_AST = null;
tmp525_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp525_AST);
match(KW_TITLE);
{
_loop388:
do {
if (((LA(1)==KW_COLOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK)))&&( LA(1) == KW_COLOR )) {
simple_color_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&(
LA(1) == KW_BGCOLOR || LA(1) == KW_FGCOLOR || LA(1) == KW_DCOLOR || LA(1) == KW_FONT
)) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop388;
}
} while (true);
}
expr();
astFactory.addASTChild(currentAST, returnAST);
title_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = title_phrase_AST;
}
/**
* Matches the <code>VIEW-AS DIALOG-BOX</code> clause.
* <p>
* Used by {@link #frame_phrase}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void view_as_dialog_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast view_as_dialog_clause_AST = null;
try { // for error handling
Aast tmp526_AST = null;
tmp526_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp526_AST);
match(KW_VIEW_AS);
Aast tmp527_AST = null;
tmp527_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp527_AST);
match(KW_DIALOG);
view_as_dialog_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = view_as_dialog_clause_AST;
}
/**
* Matches the <code>IN WINDOW</code> clause seen in many Progress language
* statements such as {@link #status_stmt} and {@link #pause_stmt}.
* <p>
* Following the keywords is a window reference which is coded here as a
* reference to the {@link #expr} rule. It is possible that there is some
* window namespace processing that is needed such that named windows can
* be referenced here. Any such processing is not handled at this time.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* <code>IN</code> keyword.
*/
public final void in_window_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_window_clause_AST = null;
try { // for error handling
Aast tmp528_AST = null;
tmp528_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp528_AST);
match(KW_IN);
Aast tmp529_AST = null;
tmp529_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp529_AST);
match(KW_WINDOW);
expr();
astFactory.addASTChild(currentAST, returnAST);
in_window_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = in_window_clause_AST;
}
/**
* Matches the <code>RETAIN, SCROLL and WIDTH</code> keywords and the required
* following numeric or decimal literal. Note that it is undocumented that
* Progress allows <code>WIDTH-CHARS</code> to be used as a synonym for
* <code>WIDTH</code> in this case. Also undocumented is the fact that the
* <code>WIDTH-PIXELS</code> keyword can be used here.
* <p>
* Used by {@link #frame_phrase}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void misc_frame_opts() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast misc_frame_opts_AST = null;
Token w = null;
Aast w_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_RETAIN:
{
Aast tmp530_AST = null;
tmp530_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp530_AST);
match(KW_RETAIN);
break;
}
case KW_SCROLL:
{
Aast tmp531_AST = null;
tmp531_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp531_AST);
match(KW_SCROLL);
break;
}
case KW_WIDTH:
{
Aast tmp532_AST = null;
tmp532_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp532_AST);
match(KW_WIDTH);
break;
}
case KW_WIDTH_C:
{
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.makeASTRoot(currentAST, w_AST);
match(KW_WIDTH_C);
w_AST.setType(KW_WIDTH);
break;
}
case KW_WIDTH_P:
{
Aast tmp533_AST = null;
tmp533_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp533_AST);
match(KW_WIDTH_P);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
misc_frame_opts_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = misc_frame_opts_AST;
}
/**
* Matches the <code>COLUMNS</code> keyword and the required <b>preceding</b>
* numeric literal. In order to eliminate ambiguity, this option must be used
* after more specific alternatives and before any alternatives that are
* less specific (only one is). This is currently used last in the calling
* rule {@link #frame_phrase} for this reason.
* <p>
* It turns out that in Progress will accept the <code>COLUMN</code> keyword
* in place of the <code>COLUMNS</code> keyword, even though they are
* supposed to be different keywords (and <code>COLUMN</code> has no
* abbreviations).
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void columns_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast columns_clause_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_COLUMNS:
{
Aast tmp534_AST = null;
tmp534_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp534_AST);
match(KW_COLUMNS);
break;
}
case KW_COL:
{
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_COL);
c_AST.setType(KW_COLUMNS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
columns_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = columns_clause_AST;
}
/**
* Disambiguate between a {@link #loop_incr} (which always starts with an
* {@link #lvalue}) and a {@link #down_clause} (which optionally starts with
* an {@link #expr}). The matching in this rule is in-lined from the original
* rules in order to left-factor the common leftmost expression construct.
*/
public final void down_clause_or_loop_incr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast down_clause_or_loop_incr_AST = null;
Token d0 = null;
Aast d0_AST = null;
Aast e0_AST = null;
Token d1 = null;
Aast d1_AST = null;
Token t = null;
Aast t_AST = null;
Aast e1_AST = null;
Aast b_AST = null;
try { // for error handling
{
if ((LA(1)==KW_DOWN) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
d0 = LT(1);
d0_AST = (Aast)astFactory.create(d0);
match(KW_DOWN);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
e0_AST = (Aast)returnAST;
{
switch ( LA(1)) {
case KW_DOWN:
{
d1 = LT(1);
d1_AST = (Aast)astFactory.create(d1);
match(KW_DOWN);
break;
}
case KW_TO:
{
t = LT(1);
t_AST = (Aast)astFactory.create(t);
match(KW_TO);
expr();
e1_AST = (Aast)returnAST;
{
if ((LA(1)==KW_BY) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
by_clause();
b_AST = (Aast)returnAST;
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
down_clause_or_loop_incr_AST = (Aast)currentAST.root;
if (d0_AST != null)
{
down_clause_or_loop_incr_AST = d0_AST;
}
else if (d1_AST != null)
{
down_clause_or_loop_incr_AST = (Aast)astFactory.make( (new ASTArray(2)).add(d1_AST).add(e0_AST));
}
else
{
// normally we must explicitly match an "EQUALS expression"
// after an lvalue, in this case this is matched by the
// expr rule and we need to transform it into the sub-tree
// that it should have been
Aast assn = e0_AST.getChildAt(0);
assn.setType(ASSIGN);
down_clause_or_loop_incr_AST = (Aast)astFactory.make( (new ASTArray(4)).add(t_AST).add(assn).add(e1_AST).add(b_AST));
}
currentAST.root = down_clause_or_loop_incr_AST;
currentAST.child = down_clause_or_loop_incr_AST!=null &&down_clause_or_loop_incr_AST.getFirstChild()!=null ?
down_clause_or_loop_incr_AST.getFirstChild() : down_clause_or_loop_incr_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = down_clause_or_loop_incr_AST;
}
/**
* Matches the <code>DOWN</code> keyword and the optional preceding
* expression. In order to eliminate ambiguity, this option must be used
* after more specific alternatives and before any alternatives that are
* less specific (none are). This is currently used last in the calling
* rule {@link #frame_phrase} for this reason.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void down_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast down_clause_AST = null;
try { // for error handling
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_DOWN )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DOWN) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
Aast tmp535_AST = null;
tmp535_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp535_AST);
match(KW_DOWN);
down_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = down_clause_AST;
}
/**
* Matches the <code>V6FRAME</code> keyword and the optional following
* keywords. ANTLR detects ambiguity due to the use of non-reserved keywords
* and the potential to use symbols and expressions in the k=1 construct in
* the calling rule {@link #frame_phrase}. To eliminate the ambiguity
* warning, ANTLR's greedy option had to be explicitly enabled.
* Since greedy is the default, this doesn't change the code generation, it
* only suppresses the warning. <b>Note that this rule checks the k=2
* lookahead before matching the <code>USE-REVERSE or USE-UNDERLINE</code>
* keywords. This may be OK but it may also bypass the match in a case where
* something unexpected follows the optional keyword. Since this cannot be
* proven for all cases, watch this code!</b>
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void version_6_frame_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast version_6_frame_clause_AST = null;
try { // for error handling
Aast tmp536_AST = null;
tmp536_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp536_AST);
match(KW_V6FRAME);
{
switch ( LA(1)) {
case KW_USE_REV:
{
Aast tmp537_AST = null;
tmp537_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp537_AST);
match(KW_USE_REV);
break;
}
case KW_USE_UND:
{
Aast tmp538_AST = null;
tmp538_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp538_AST);
match(KW_USE_UND);
break;
}
case EOF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
version_6_frame_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = version_6_frame_clause_AST;
}
/**
* Matches all valid filenames (relative and absolute). This rule can match
* any lexer token in the first position and that matching will continue until
* whitespace is encountered or if one of a specific list of excluded token
* types is matched. Since this matching is so broad, it is highly ambiguous
* and this rule must be placed as the last alternative in callers such that
* it doesn't overmatch. This means that it can conflict with literals,
* reserved keywords, operators and any other unexpected text in a 4GL
* program.
* <p>
* Token types that end the merging process:
* <p>
* <pre>
* DOT
* EOF
* LPARENS
* RPARENS
* </pre>
* <p>
* The lexer has a <code>FILENAME</code> token but it does not have enough
* context to differentiate the full range of filenames that are possible.
* In Progress, when a filename is matched, the lexing changes to an approach
* that seems to be based on whitespace. Any text at all can be matched until
* a separate excluded token type or whitespace is encountered. This has been
* duplicated in the init action of this rule. The <code>mergeUntilWS</code>
* method is used to merge all the different tokens using this same approach.
* It is called from the init action and the resulting single merged token
* will have its type set to <code>FILENAME</code>.
* <p>
* The matching portion of this rule is defined as a single token that
* matches the union of the <code>FILENAME</code> token type and the set of
* all tokens that are not a <code>DOT</code>.
*
* @param exclude
* Provides a list of token types to disallow from merge into a single filename
* node. It is OK to pass <code>null</code> (don't exclude anything additional).
* By default DOT and EOF are already excluded.
*/
public final void filename(
int[] exclude
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast filename_AST = null;
try { // for error handling
mergeUntilWS(exclude);
LT(1).setType(FILENAME);
{
if ((LA(1)==FILENAME)) {
Aast tmp539_AST = null;
tmp539_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp539_AST);
match(FILENAME);
}
else if ((_tokenSet_96.member(LA(1)))) {
Aast tmp540_AST = null;
tmp540_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp540_AST);
matchNot(DOT);
Aast tmp541_AST = null;
tmp541_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp541_AST);
matchNot(DOT);
Aast tmp542_AST = null;
tmp542_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp542_AST);
matchNot(DOT);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
filename_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = filename_AST;
}
/**
* Matches the <code>COLOR</code> keyword and the required following color
* phrase. Uses {@link #color_phrase}. This is the simplified version of
* {@link #color_spec}.
* <p>
* Used by {@link #put_screen_stmt} and {@link #choose_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void simple_color_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_color_clause_AST = null;
try { // for error handling
Aast tmp543_AST = null;
tmp543_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp543_AST);
match(KW_COLOR);
color_phrase();
astFactory.addASTChild(currentAST, returnAST);
simple_color_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_21);
}
returnAST = simple_color_clause_AST;
}
/**
* Matches the <code>COLOR</code> language statement and the required
* following color specification. This rule uses an inlined version of the
* {@link #color_spec} with modifications to allow an empty color phrase.
* The {@link #display_color_clause} and {@link #prompt_color_clause} rules
* provide the bulk of the implementation.
* <p>
* Actual customer code shows that a {@link #format_phrase} can be placed
* after the {@link #lvalue} used to describe each field. In addition, at
* the end of the statement an optional {@link #frame_phrase} is matched.
* Although it is documented that at least 1 field (lvalue) is required,
* customer code has shown this to be optional.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*/
public final void color_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast color_stmt_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
{
Aast tmp544_AST = null;
tmp544_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp544_AST);
match(KW_COLOR);
{
if ((LA(1)==KW_PROMPT||LA(1)==KW_PRMT_FOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
prompt_color_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_DISP) && (_tokenSet_97.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
(sym.lookupVariable(LT(2).getText()) != -1 || sym.isField(LT(2).getText())) &&
LA(2) != KW_MESSAGES
)) {
Aast tmp545_AST = null;
tmp545_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp545_AST);
match(KW_DISP);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
display_color_clause();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_PROMPT||LA(1)==KW_PRMT_FOR)) {
prompt_color_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_97.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
color_field_list(fields);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
color_stmt_AST = (Aast)currentAST.root;
String frame = getFrameName(fp_AST);
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
setUseDictExps(frame, fp_AST, color_stmt_AST);
}
color_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = color_stmt_AST;
}
/**
* Matches the <code>PROMPT color_phrase</code> construct used in a color
* specification. This supports an undocumented Progress feature, where
* <code>PROMPT-FOR</code> is accepted as a synonym to <code>PROMPT</code>.
* <p>
* Used by {@link #color_spec}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void prompt_color_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast prompt_color_clause_AST = null;
Token p = null;
Aast p_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_PROMPT:
{
Aast tmp546_AST = null;
tmp546_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp546_AST);
match(KW_PROMPT);
break;
}
case KW_PRMT_FOR:
{
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(KW_PRMT_FOR);
p_AST.setType(KW_PROMPT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
color_phrase();
astFactory.addASTChild(currentAST, returnAST);
prompt_color_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = prompt_color_clause_AST;
}
/**
* Matches the <code>DISPLAY color_phrase</code> construct used in a color
* specification (actually the <code>DISPLAY</code> keyword is optional).
* <p>
* Used by {@link #color_spec}.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*/
public final void display_color_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast display_color_clause_AST = null;
try { // for error handling
{
if ((LA(1)==KW_DISP) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
Aast tmp547_AST = null;
tmp547_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp547_AST);
match(KW_DISP);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
color_phrase();
astFactory.addASTChild(currentAST, returnAST);
display_color_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = display_color_clause_AST;
}
/**
* Aggregates (in a tree building sense) the list of all fields having
* color(s) set by a {@link #color_stmt}. Calls {@link #lvalue} and
* {@link #format_phrase} and roots everything at a node of type
* <code>CONTENT_ARRAY</code>.
*
* @param fields
* Set into which all database field references should be stored.
*/
public final void color_field_list(
Set<Aast> fields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast color_field_list_AST = null;
Aast l_AST = null;
try { // for error handling
Aast fld = null;
String symbolName = null;
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(CONTENT_ARRAY,""));
{
_loop397:
do {
if ((_tokenSet_64.member(LA(1)))) {
allowSymbolMatch = true;
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// reset each loop iteration
symbolName = null;
fld = null;
if (l_AST.getType() == SYMBOL)
{
symbolName = l_AST.getText();
}
else
{
fld = findFieldNode(l_AST);
if (fld != null)
{
fields.add(fld);
}
}
allowSymbolMatch = false;
{
if ((_tokenSet_98.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_phrase(symbolName, fld, true, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_97.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop397;
}
} while (true);
}
color_field_list_AST = (Aast)currentAST.root;
if (color_field_list_AST.getNumberOfChildren() == 0)
{
color_field_list_AST = null;
}
currentAST.root = color_field_list_AST;
currentAST.child = color_field_list_AST!=null &&color_field_list_AST.getFirstChild()!=null ?
color_field_list_AST.getFirstChild() : color_field_list_AST;
currentAST.advanceChildToEnd();
color_field_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_99);
}
returnAST = color_field_list_AST;
}
/**
* Matches the color_phrase construct of the Progress 4GL language.
* This implementation is relaxed compared to the 4GL and has the following
* limitations:
* <p>
* <ul>
* <li>dos-hex-attributes are not supported
* <li>Windows color attributes are not supported
* </ul>
* <p>
* Valid color specification options are these keywords: NORMAL, INPUT and
* MESSAGES. They have a unique capacity: they can be abbreviated down to 1
* character even though there are conflicting keywords in 4GL! This is how it
* works.
* <p>
* The NORMAL keyword can be coded as anything between N and NORMAL, excluding
* NO, which is a reserved 4GL keyword and can't be used in color-phrase.
* <p>
* The INPUT keyword can be coded as anything between I and INPUT, although
* normally this keyword can't be abbreviated. There is a conflicting 4GL
* keyword IN, but in the color-phrase it assumes the role of INPUT.
* <p>
* The MESSAGES keyword can be coded as anything between M and MESSAGES. There
* is a conflicting 4GL keyword MESSAGE, which can't be abbreviated, but it
* assumes the role of MESSAGES when used in a color-phrase.
* <p>
* This explains why one sees KW_IN and KW_MSG as alternatives in this rule.
* In both cases, the token type is converted to the originally required type.
* The KW_INPUT, KW_NORMAL and KW_MESSAGES are defined as having no
* abbreviations, otherwise they would conflict with many other keywords.
* Instead, this rule checks to see if SYMBOL type tokens (which abbreviations
* are) represent a valid abbreviation and sets the token type explicitly.
* <p>
* Customer source has shown that reserved keywords such as
* <code>UNDERLINE</code> can be found in a color phrase (this is
* undocumented by Progress and is currently supported on a case by case
* basis.
* <p>
* Note that ANTLR reports ambiguity for this rule. This is due to the call to
* protermcap, which ultimately calls the symbol rule. This conflicts with
* the color_spec rule where KW_PROMPT designates the optional part. This
* ambiguity is in ANTLR logic only. There is no ambiguity in the generated
* code. For this reason, ambiguity warnings are suppressed for this rule.
* <p>
* This rule is called from {@link #color_spec} rule.
*/
public final void color_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast color_phrase_AST = null;
Token i = null;
Aast i_AST = null;
Token m = null;
Aast m_AST = null;
Aast s_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(COLOR_PHRASE,""));
// DOT and EOF are hard coded in the worker routine
int[] exclude = new int[]
{
LPARENS,
RPARENS
};
{
if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NORMAL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp548_AST = null;
tmp548_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp548_AST);
match(KW_NORMAL);
}
else if ((LA(1)==KW_IN||LA(1)==KW_INPUT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_INPUT:
{
Aast tmp549_AST = null;
tmp549_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp549_AST);
match(KW_INPUT);
break;
}
case KW_IN:
{
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.addASTChild(currentAST, i_AST);
match(KW_IN);
i_AST.setType(KW_INPUT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_MSG||LA(1)==KW_MESSAGES) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_MESSAGES:
{
Aast tmp550_AST = null;
tmp550_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp550_AST);
match(KW_MESSAGES);
break;
}
case KW_MSG:
{
m = LT(1);
m_AST = (Aast)astFactory.create(m);
astFactory.addASTChild(currentAST, m_AST);
match(KW_MSG);
m_AST.setType(KW_MESSAGES);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
filename(exclude);
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
String t = s_AST.getText().toLowerCase();
if ("normal".startsWith(t))
{
s_AST.setType(KW_NORMAL);
}
else if ("input".startsWith(t))
{
s_AST.setType(KW_INPUT);
}
else if ("messages".startsWith(t))
{
s_AST.setType(KW_MESSAGES);
}
else
{
s_AST.setType(SYMBOL);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
color_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = color_phrase_AST;
}
/**
* Matches the <code>VALUE( expression )</code> construct which converts
* an expression into a symbol-like result (example: a type of name). This is
* used in many locations such as {@link #color_phrase} and {@link #run_stmt}.
* <p>
* Working 4GL code has shown that unquoted text can be present here instead
* of a valid expression. Progress seems to treat that as if the text was
* a quoted string literal. This undocumented feature is supported here by
* setting a flag to allow a symbol match in the expression processing.
* <p>
* Separating this allows the AST to be built cleanly and also centralizes
* the logic for reuse.
*/
public final void value() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast value_AST = null;
try { // for error handling
allowSymbolMatch = true;
Aast tmp551_AST = null;
tmp551_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp551_AST);
match(KW_VALUE);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
allowSymbolMatch = false;
value_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = value_AST;
}
/**
* Matches the column format phrase construct of the Progress 4GL language
* which is used in a <code>DEFINE BROWSE</code>. All of its options can be
* specified in any order. This is generally a subset of the normal
* {@link #format_phrase}, however there is one case that can be matched
* here (<code>KW_WIDTH</code>) that cannot be matched in a format phrase.
* <p>
* This rule is separate since there is only a small subset of the possible
* choices that can be matched, this reduces ambiguity. Note that the result
* is still rooted at a <code>FORMAT_PHRASE</code> node.
* <p>
* The following list of rules are called to properly implement the tree
* building:
* <p>
* <ul>
* <li> {@link #label}
* <li> {@link #misc_frame_opts} (for the WIDTH, WIDTH-CHARS and WIDTH-PIXELS constructs only,
* the WIDTH-CHARS and WIDTH-PIXELS options are undocumented but were found in customer
* source)
* <li> {@link #ui_stuff}
* <li> {@link #column_label}
* <li> {@link #at_base_field_clause}
* <li> {@link #view_as_phrase}
* </ul>
* <p>
* We have disabled ambiguity warnings because there is no real issue with
* the <code>ui_stuff</code>.
* <p>
* The '@' base_field clause (accessed via <code>at_base_field_clause</code>)
* is not documented as part of this phrase but customer examples show that
* this can be embedded inside one. To simplify logic, this has been merged.
* <p>
* Called from {@link #column_spec}.
*/
public final void column_format_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast column_format_phrase_AST = null;
try { // for error handling
String bogus = null;
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(FORMAT_PHRASE,""));
{
_loop429:
do {
if ((LA(1)==KW_LABEL||LA(1)==KW_NO_LABEL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_LABEL:
{
label(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_LABEL:
{
Aast tmp552_AST = null;
tmp552_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp552_AST);
match(KW_NO_LABEL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((_tokenSet_67.member(LA(1))) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_WIDTH || LA(1) == KW_WIDTH_C || LA(1) == KW_WIDTH_P )) {
misc_frame_opts();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
LA(1) == KW_COL_BGC || LA(1) == KW_COL_DC || LA(1) == KW_COL_FGC || LA(1) == KW_COL_FONT ||
LA(1) == KW_COL_PFC || LA(1) == KW_LAB_BGC || LA(1) == KW_LAB_DC || LA(1) == KW_LAB_FGC ||
LA(1) == KW_LAB_FONT || LA(1) == KW_LAB_PFC
)) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_COL_LAB) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
column_label();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_HYPERLNK) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
hyperlink_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_EH_SR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp553_AST = null;
tmp553_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp553_AST);
match(KW_NO_EH_SR);
}
else if ((LA(1)==KW_NO_EH_FL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp554_AST = null;
tmp554_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp554_AST);
match(KW_NO_EH_FL);
}
else if ((LA(1)==AT) && (_tokenSet_64.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
bogus=at_base_field_clause(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_VIEW_AS) && (_tokenSet_56.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
view_as_phrase(null);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop429;
}
} while (true);
}
column_format_phrase_AST = (Aast)currentAST.root;
// safety first since this rule can have everything be optional
if (column_format_phrase_AST.getNumberOfChildren() == 0)
{
// get rid of the artificial root we previously created
column_format_phrase_AST = null;
}
currentAST.root = column_format_phrase_AST;
currentAST.child = column_format_phrase_AST!=null &&column_format_phrase_AST.getFirstChild()!=null ?
column_format_phrase_AST.getFirstChild() : column_format_phrase_AST;
currentAST.advanceChildToEnd();
column_format_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = column_format_phrase_AST;
}
/**
* Matches the phrase which specifies which columns in the
* {@link #column_spec} are enabled for input (always is preceded by the
* <code>ENABLE</code> keyword).
* <p>
* Calls {@link #browse_all_list}, {@link #lvalue}, {@link #help_string}
* and {@link #validate}.
*
* @param enabledFields
* A set to collect the fully qualified field names which are enabled.
* @param exceptFields
* A set to collect the fully qualified field names which are excepted from enable.
*/
public final void browse_enable_phrase(
Set<String> enabledFields, Set<String> exceptFields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast browse_enable_phrase_AST = null;
try { // for error handling
Aast tmp555_AST = null;
tmp555_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp555_AST);
match(KW_ENABLE);
{
if ((LA(1)==KW_ALL)) {
browse_all_list(exceptFields);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1)))) {
{
int _cnt419=0;
_loop419:
do {
if ((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
column_ref(enabledFields);
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt419>=1 ) { break _loop419; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt419++;
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
browse_enable_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = browse_enable_phrase_AST;
}
/**
* Matches the shorthand of specifying all fields (and optional exclude list
* of fields) instead of an explicit field list, in the
* {@link #browse_enable_phrase} rule. Uses {@link #except_list}.
* <p>
* This rule is naturally greedy (in matching a list of field names to
* exclude, and doing so in a loop. ANTLR warns that this causes ambiguity.
* The greedy option is used to tell ANTLR to disable the warning, though it
* has no impact on the actual code generation.
* <p>
* Separated from the main rule to properly build the AST without complexity.
* This is the only reason such a simple rule is implemented separately.
*
* @param exceptFields
* A set to collect the fully qualified field names.
*/
public final void browse_all_list(
Set<String> exceptFields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast browse_all_list_AST = null;
try { // for error handling
Aast tmp556_AST = null;
tmp556_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp556_AST);
match(KW_ALL);
{
if ((LA(1)==KW_EXCEPT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
except_list(exceptFields);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
browse_all_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = browse_all_list_AST;
}
/**
* Defines one column element in a list of columns to enable in the
* {@link #browse_enable_phrase}. Returns a node of type
* <code>COLUMN_REF</code> and uses {@link #lvalue}, {@link #help_string}
* and {@link #validate} rule references.
* @param enabledFields
* A set to collect the fully qualified field names which are enabled.
*/
public final void column_ref(
Set<String> enabledFields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast column_ref_AST = null;
Aast l_AST = null;
Aast v_AST = null;
try { // for error handling
boolean schem = false;
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(COLUMN_REF,"column ref"));
{
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
schem = l_AST.getType() > BEGIN_FIELDTYPES && l_AST.getType() < END_FIELDTYPES;
if (schem)
{
enabledFields.add((String) l_AST.getAnnotation("schemaname"));
}
{
_loop423:
do {
if ((LA(1)==KW_HELP) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
help_string();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_VALIDATE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
validate(schem ? (String) l_AST.getAnnotation("schemaname") : null);
v_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_AUTO_RET) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp557_AST = null;
tmp557_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp557_AST);
match(KW_AUTO_RET);
}
else if ((LA(1)==KW_DIS_A_ZA) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp558_AST = null;
tmp558_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp558_AST);
match(KW_DIS_A_ZA);
}
else {
break _loop423;
}
} while (true);
}
}
column_ref_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = column_ref_AST;
}
/**
* Matches the <code>HYPERLINK event-name</code> clause (FWD extension). Used in the
* {@link #column_format_phrase}.
*/
public final void hyperlink_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast hyperlink_clause_AST = null;
try { // for error handling
Aast tmp559_AST = null;
tmp559_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp559_AST);
match(KW_HYPERLNK);
Aast tmp560_AST = null;
tmp560_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp560_AST);
match(STRING);
hyperlink_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = hyperlink_clause_AST;
}
/**
* Matches the <code>ROW-HEIGHT-CHARS and ROW-HEIGHT-PIXELS</code> construct
* with its required following integer constant. Used in the
* {@link #browse_options_phrase}.
* <p>
* Separating this allows the AST to be built cleanly and also centralizes
* the logic for reuse.
*/
public final void row_height_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast row_height_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_ROW_H_C:
{
Aast tmp561_AST = null;
tmp561_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp561_AST);
match(KW_ROW_H_C);
break;
}
case KW_ROW_H_P:
{
Aast tmp562_AST = null;
tmp562_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp562_AST);
match(KW_ROW_H_P);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
row_height_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = row_height_clause_AST;
}
/**
* Matches the <code>INITIAL</code> keyword and the required single literal
* or a left/right bracket bounded (and comma separated) list of literals.
* Used by {@link #def_var_stmt} and the subtree is rooted by the
* <code>INITIAL</code> keyword. Note that the commas are dropped from the
* resulting AST to simplify processing.
* <p>
* A special case exists for the <code>TODAY</code> keyword. Normally,
* an initializer would only accept a {@link #literal} but for variables
* of type <code>DATE</code>, the <code>TODAY</code> 'function' can also
* be used. To accomodate this requirement, the {@link #initializer_constant}
* rule is called.
* <p>
* No testing is done to check the type(s) of the literal(s) against the
* expected type as set by the AS or LIKE clause.
* <p>
* A count is returned, so that the case where an extent does not have a constant
* still allows for the extent to become fixed.
*
* @param vtype
* A token type that describes type of the variable being initialized. This is
* the type of the child of the <code>KW_AS</code> or <code>KW_LIKE</code> node.
*
* @return The count of the number of initializers.
*/
public final int initializer(
int vtype
) throws RecognitionException, TokenStreamException {
int count = 1;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast initializer_AST = null;
Token lb = null;
Aast lb_AST = null;
Token rb = null;
Aast rb_AST = null;
try { // for error handling
Aast tmp563_AST = null;
tmp563_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp563_AST);
match(KW_INIT);
{
if ((_tokenSet_100.member(LA(1)))) {
initializer_constant(vtype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==LBRACKET)) {
lb = LT(1);
lb_AST = (Aast)astFactory.create(lb);
match(LBRACKET);
hide(lb);
initializer_constant(vtype);
astFactory.addASTChild(currentAST, returnAST);
{
_loop1100:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
initializer_constant(vtype);
astFactory.addASTChild(currentAST, returnAST);
count++;
}
else {
break _loop1100;
}
} while (true);
}
rb = LT(1);
rb_AST = (Aast)astFactory.create(rb);
match(RBRACKET);
hide(rb);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
initializer_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = initializer_AST;
return count;
}
/**
* Matches the <code>DECIMALS</code> keyword and the required following
* integer literal. Used by {@link #def_var_stmt} and the subtree is rooted by
* the keyword (which is the reason for using a separate rule for something so
* simple).
*/
public final void decimals_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast decimals_clause_AST = null;
try { // for error handling
Aast tmp564_AST = null;
tmp564_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp564_AST);
match(KW_DECIMALS);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
decimals_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = decimals_clause_AST;
}
/**
* Matches the <code>CASE-SENSITIVE</code> keyword with the optional
* preceeding <code>NOT</code> keyword. Separated to enhance the tree build.
* <p>
* Called by {@link #regular_parm}, {@link #temp_table_field_options} and
* {@link #def_var_stmt}.
*/
public final void case_sensitive() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast case_sensitive_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_NOT:
{
Aast tmp565_AST = null;
tmp565_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp565_AST);
match(KW_NOT);
break;
}
case KW_CASE_SEN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp566_AST = null;
tmp566_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp566_AST);
match(KW_CASE_SEN);
case_sensitive_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = case_sensitive_AST;
}
/**
* Matches all forms of inner blocks (nestable blocks - not procedures and
* not functions) including <code>DO</code>, <code>REPEAT</code> and
* <code>FOR</code>.
* <p>
* As all 3 of these language statements can end with a <code>COLON</code>
* or a <code>DOT</code>, this rule implements this match in common code.
* <p>
* The core of this rule specifies multiple alternatives that match the
* Progress language statements <code>DO, REPEAT</code>
* ({@link #do_repeat_stmt}) and <code>FOR</code> ({@link #for_stmt}).
* <p>
* This rule also matches the <code>EDITING</code> keyword and allows this
* rule to be used as the editing phrase. This works because the calling
* rule (<code>inner_block</code>) is identical in syntax to the editing
* block. Note that a minor drawback to this approach is that no error
* is thrown if someone tries to use an editing phrase in the top level of
* a Progress program, although this would not be valid Progress source.
* <p>
* These required keywords should provide the differentiation needed to
* eliminate the ambiguity that is generated by having the optional
* <code>symbol</code> reference as the first token, <b>however it turns out
* that the generated ANTLR code is not smart enough to handle this.</b>
* Instead the {@link #block} top-level rule has a semantic predicate that
* reimplements the dependencies implemented by this rule's logic.
* <p>
* Called by {@link #inner_block}.
*/
public final void block_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast block_list_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_DO:
case KW_REPEAT:
{
do_repeat_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FOR:
{
for_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_EDITING:
{
Aast tmp567_AST = null;
tmp567_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp567_AST);
match(KW_EDITING);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
block_term();
astFactory.addASTChild(currentAST, returnAST);
block_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = block_list_AST;
}
/**
* Matches both <code>DO</code> and <code>REPEAT</code> Progress 4GL language
* statements. This is possible because other than the primary (leftmost)
* keyword being different (<code>DO</code> versus <code>REPEAT</code>), the
* structure of the 2 statements is syntactically identical. The meaning of
* the 2 statements is different but this does not affect parsing at all.
* <p>
* All possible common clauses between this rule and {@link #for_stmt}
* have been factored into {@link #common_block_options}.
* <p>
* In fact, if it were not for some small but meaningful differences, there
* could have been a common rule for all 3 inner block statements.
* <p>
* Called by {@link #block_list}.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Uses the following rules:
* {@link #for_record_spec}
* {@link #preselect_phrase}
* {@link #common_block_options}
*/
public final void do_repeat_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast do_repeat_stmt_AST = null;
try { // for error handling
Aast node = null;
Aast loop = null;
{
switch ( LA(1)) {
case KW_DO:
{
Aast tmp568_AST = null;
tmp568_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp568_AST);
match(KW_DO);
break;
}
case KW_REPEAT:
{
Aast tmp569_AST = null;
tmp569_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp569_AST);
match(KW_REPEAT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop473:
do {
if ((LA(1)==KW_FOR) && (_tokenSet_13.member(LA(2))) && (_tokenSet_101.member(LA(3)))) {
for_record_spec(false, true, true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_PRESEL) && (_tokenSet_102.member(LA(2))) && (_tokenSet_103.member(LA(3)))) {
preselect_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
node=common_block_options();
astFactory.addASTChild(currentAST, returnAST);
// node is replaced every time through the loop so we must
// cache off the first non-null result for post-processing
if (loop == null && node != null)
{
loop = node;
}
}
else {
break _loop473;
}
} while (true);
}
do_repeat_stmt_AST = (Aast)currentAST.root;
// implement any deferred tree processing for a mis-matched loop
// increment sub-tree
if (loop != null)
{
do_repeat_stmt_AST.addChild(loop);
}
sym.endIndexFieldSearch();
do_repeat_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = do_repeat_stmt_AST;
}
/**
* Matches <code>FOR</code> Progress 4GL language statement.
* <p>
* All possible common clauses between this rule and {@link #do_repeat_stmt}
* have been factored into {@link #common_block_options}.
* <p>
* In fact, if it were not for some small but meaningful differences,
* there could have been a common rule for all 3 inner block statements.
* In particular, a variant of the {@link #preselect_phrase} rule that is
* used by the <code>do_repeat_stmt</code> is inlined in here. The
* inline grammar differs in that there is no <code>preselect</code> keyword.
* <p>
* Called by {@link #block_list}.
* <p>
* Uses {@link #each_first_last_spec} to implement a common record phrase
* list.
*/
public final void for_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_stmt_AST = null;
try { // for error handling
Aast node = null;
Aast loop = null;
Aast tmp570_AST = null;
tmp570_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp570_AST);
match(KW_FOR);
each_first_last_spec(true, false);
astFactory.addASTChild(currentAST, returnAST);
{
_loop476:
do {
if ((_tokenSet_85.member(LA(1)))) {
node=common_block_options();
astFactory.addASTChild(currentAST, returnAST);
// node is replaced every time through the loop so we must
// cache off the first non-null result for post-processing
if (loop == null && node != null)
{
loop = node;
}
}
else {
break _loop476;
}
} while (true);
}
for_stmt_AST = (Aast)currentAST.root;
// implement any deferred tree processing for a mis-matched loop
// increment sub-tree
if (loop != null)
{
for_stmt_AST.addChild(loop);
}
sym.endIndexFieldSearch();
for_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = for_stmt_AST;
}
/**
* This is a simple (flat) list of alternatives for all language statements
* that do not have anything to do with a starting or ending a Progress 4GL
* block. It is critical that each alternative in this list be properly
* defined such that there is no unresolved ambiguity OR such that the
* alternatives can be ordered so that ANTLR can eliminate ambiguity by
* using standard lookahead (see options starting with create or delete).
* Any single word language statement should appear after any language
* statement that starts with the same keyword but then has a 2nd required
* keyword by which the two can be differentiated.
* <p>
* Although ANTLR properly handles the ambiguity of statements that start
* with common keywords like <code>CREATE</code> (assuming they are ordered
* more specific to less specific), it still can detect ambiguity. For this
* reason, ambiguity warnings have been disabled. <b>As statements are
* added to this rule it is critical that the actual logic be reviewed to
* ensure that no real ambiguity has been added.</b>
* <p>
* Simple (single keyword, no options, no data or expressions) language
* statements are implemented 'in-line' in this rule. All statements
* simple or rule references) are listed alphabetically unless there is a
* need to avoid ambiguity.
* <p>
* This rule seems to be where the statement-ending <code>DOT</code> should
* be matched. However, there are locations such as {@link #if_stmt} and
* {@link #case_stmt} that don't easily fit into this plan. So the end of
* statement delimiter is coded in each statement separately.
* <p>
* Do NOT put an <code>END</code> statement into this list. The nested
* nature of the grammar's block structure is only possible because the
* <code>END</code> statement is only found at the end of a block. This
* allows the ends of blocks to be identified since any loop that is
* matching statements, assignments... will naturally stop when it hits
* an end statement. See {@link #single_block}.
* <p>
* Called by {@link #statement}.
*/
public final void stmt_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast stmt_list_AST = null;
Token p = null;
Aast p_AST = null;
Token ev = null;
Aast ev_AST = null;
try { // for error handling
if (isUserDefFunctionCall(LT(1), LT(2)))
{
return;
}
CommonToken next = (CommonToken) LT(1);
CommonToken after = (CommonToken) LT(2);
// RUN stmt filenames that start with a DOT need some processing here to allow
// matching run_stmt below
if (next != null && next.getType() == KW_RUN &&
after != null && after.getType() == DOT &&
!followedByWhitespace(after))
{
// rewrite the type of the token to enable matching/merging in run_stmt
after.setType(SYMBOL);
}
{
switch ( LA(1)) {
case KW_ACCUM:
{
accumulate_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_APPLY:
{
apply_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ASSIGN:
{
assign_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BELL:
{
Aast tmp571_AST = null;
tmp571_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp571_AST);
match(KW_BELL);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BLK_LVL:
{
block_level_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BUF_COMP:
case KW_BUF_COPY:
{
buffer_compare_or_copy_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CALL:
{
call_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CASE:
{
case_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CATCH:
{
catch_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CHOOSE:
{
choose_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CLEAR:
{
clear_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_COMPILE:
{
compile_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CONN:
{
connect_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CPY_LOB:
{
copy_lob_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DEFINE:
{
define_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DICT:
{
Aast tmp572_AST = null;
tmp572_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp572_AST);
match(KW_DICT);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DISCONN:
{
disconnect_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DISP:
{
display_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_EMPTY:
{
empty_temp_table_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ENABLE:
{
enable_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_EXPORT:
{
export_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FINALLY:
{
finally_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FIND:
{
find_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FORMAT:
{
form_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_GET:
{
get_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_GET_K_V:
{
get_key_value_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_HIDE:
{
hide_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IF:
{
if_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IMPORT:
{
import_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_INPUT:
case KW_IN_OUT:
case KW_OUTPUT:
{
io_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LOAD:
{
load_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_MSG:
{
msg_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LEAVE:
case KW_NEXT:
{
next_or_leave_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NEXT_PMT:
{
next_prompt_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ON:
{
on_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OS_APPND:
case KW_OS_COPY:
case KW_OS_REN:
{
os_misc_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OS_MKDIR:
{
os_create_dir_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OS_DEL:
{
os_delete_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PAGE:
{
page_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PAUSE:
{
pause_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PROCESS:
{
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(KW_PROCESS);
p_AST.setType(PROCESS_EVENTS);
ev = LT(1);
ev_AST = (Aast)astFactory.create(ev);
match(KW_EVENTS);
hide(ev);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PUBLISH:
{
publish_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PUT_K_V:
{
put_key_value_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_QUIT:
{
Aast tmp573_AST = null;
tmp573_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp573_AST);
match(KW_QUIT);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_RAW_TRAN:
{
raw_transfer_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_READKEY:
{
readkey_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_REPOS:
{
reposition_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_RETURN:
{
return_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ROUTINEL:
{
routine_level_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SAVE:
{
save_cache_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SCROLL:
{
scroll_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SEEK:
{
seek_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BTOS:
case KW_CTOS:
case KW_DOS:
case KW_OS2:
case KW_OS_CMD:
case KW_UNIX:
case KW_VMS:
{
shell_command_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SHOW_ST:
{
Aast tmp574_AST = null;
tmp574_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp574_AST);
match(KW_SHOW_ST);
{
switch ( LA(1)) {
case KW_CLEAR:
{
Aast tmp575_AST = null;
tmp575_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp575_AST);
match(KW_CLEAR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_STOP:
{
Aast tmp576_AST = null;
tmp576_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp576_AST);
match(KW_STOP);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_STATUS:
{
status_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SUBSCRIB:
{
subscribe_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SYS_HELP:
{
system_help_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TRIGGER:
{
trigger_procedure_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TRAN_MOD:
{
transaction_mode_auto_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UNDERLIN:
{
underline_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UNDO:
{
undo_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UNLOAD:
{
unload_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UNSUBSCR:
{
unsubscribe_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DOWN:
case KW_UP:
{
up_or_down_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_USE:
{
use_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_USING:
{
using_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_VALIDATE:
{
validate_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_VIEW:
{
view_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_EXC_LOCK:
case KW_NO_LOCK:
case KW_SH_LOCK:
{
empty_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OPEN_URL:
{
p2j_open_url_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OPENMIME:
{
open_mime_resource_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_WEB_FUP:
{
web_file_upload_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((LA(1)==KW_CLOSE) && (LA(2)==KW_QUERY) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
close_query_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CLOSE) && (LA(2)==KW_STORPROC) && (_tokenSet_27.member(LA(3)))) {
close_stored_proc_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_COLOR))&&( LA(1) == KW_COLOR )) {
color_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_ALIAS) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
create_alias_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_BROWSE) && (_tokenSet_85.member(LA(3)))) {
create_browse_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_BUFFER) && (_tokenSet_85.member(LA(3)))) {
create_buffer_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_CALL) && (_tokenSet_85.member(LA(3)))) {
create_call_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_CLNT_PRL) && (_tokenSet_85.member(LA(3)))) {
create_client_principal_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_DATABASE) && (_tokenSet_24.member(LA(3)))) {
create_database_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_DATASET) && (_tokenSet_85.member(LA(3)))) {
create_dataset_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_DATA_SRC) && (_tokenSet_85.member(LA(3)))) {
create_datasource_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_QUERY) && (_tokenSet_85.member(LA(3)))) {
create_query_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_SAX_ATTR||LA(2)==KW_SAX_READ||LA(2)==KW_SAX_WRIT) && (_tokenSet_85.member(LA(3)))) {
create_sax_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_SERVER) && (_tokenSet_85.member(LA(3)))) {
create_server_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_SOAP_HDR) && (_tokenSet_85.member(LA(3)))) {
create_soap_header_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_SOAP_HER) && (_tokenSet_85.member(LA(3)))) {
create_soap_header_entryref_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_SRV_SOCK||LA(2)==KW_SOCKET) && (_tokenSet_85.member(LA(3)))) {
create_socket_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_TEMP_TAB) && (_tokenSet_85.member(LA(3)))) {
create_temp_table_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_WID_POOL) && (_tokenSet_21.member(LA(3)))) {
create_widget_pool_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_X_DOC||LA(2)==KW_X_NODE) && (_tokenSet_85.member(LA(3)))) {
create_xml_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_CREATE) && (_tokenSet_13.member(LA(2))) && (LA(3)==DOT||LA(3)==KW_NO_ERROR||LA(3)==KW_USING))&&( sym.isTable(LT(2).getText()) )) {
create_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
create_widget_or_object_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_ADVISE)) {
dde_advise_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_EXECUTE)) {
dde_execute_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_GET)) {
dde_get_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_INITIATE)) {
dde_initiate_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_REQUEST)) {
dde_request_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_SEND)) {
dde_send_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DDE) && (LA(2)==KW_TERMINAT)) {
dde_terminate_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DELETE) && (LA(2)==KW_ALIAS) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
delete_alias_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DELETE) && (LA(2)==KW_OBJECT) && (_tokenSet_24.member(LA(3)))) {
delete_object_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DELETE) && (LA(2)==KW_PROC) && (_tokenSet_24.member(LA(3)))) {
delete_procedure_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DELETE) && (LA(2)==KW_WIDGET) && (_tokenSet_85.member(LA(3)))) {
delete_widget_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DELETE) && (LA(2)==KW_WID_POOL) && (_tokenSet_21.member(LA(3)))) {
delete_widget_pool_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DELETE) && (_tokenSet_13.member(LA(2))) && (LA(3)==DOT||LA(3)==KW_NO_ERROR||LA(3)==KW_VALIDATE)) {
delete_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DISABLE) && (LA(2)==KW_TRIGGERS)) {
disable_triggers_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DISABLE) && (_tokenSet_104.member(LA(2)))) {
disable_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_INSERT) && (_tokenSet_13.member(LA(2))) && (_tokenSet_105.member(LA(3)))) {
insert_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_OPEN) && (LA(2)==KW_QUERY) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
open_query_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_PUT) && (LA(2)==KW_SCREEN) && (_tokenSet_21.member(LA(3)))) {
put_screen_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_PUT) && (LA(2)==KW_CURSOR) && (_tokenSet_106.member(LA(3)))) {
put_cursor_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_PUT) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
put_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RELEASE) && (LA(2)==KW_EXTERN) && (_tokenSet_24.member(LA(3)))) {
release_external_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RELEASE) && (LA(2)==KW_OBJECT) && (_tokenSet_24.member(LA(3)))) {
release_object_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RELEASE) && (_tokenSet_13.member(LA(2))) && (LA(3)==DOT||LA(3)==KW_NO_ERROR)) {
release_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RUN) && (LA(2)==KW_STORPROC) && (_tokenSet_27.member(LA(3)))) {
run_stored_proc_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RUN) && (LA(2)==KW_SUPER) && (LA(3)==DOT||LA(3)==KW_NO_ERROR||LA(3)==LPARENS)) {
run_super_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RUN) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
run_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_107.member(LA(1))) && (_tokenSet_82.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
set_or_update_or_prompt_for_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_SUPER))&&( constStmts > 0 )) {
super_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SYS_DLG) && (LA(2)==KW_COLOR)) {
system_dialog_color_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SYS_DLG) && (LA(2)==KW_FONT)) {
system_dialog_font_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SYS_DLG) && (LA(2)==KW_GET_DIR)) {
system_dialog_get_dir_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SYS_DLG) && (LA(2)==KW_GET_FILE)) {
system_dialog_get_file_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SYS_DLG) && (LA(2)==KW_PRT_SET)) {
system_dialog_printer_setup_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_THIS_OBJ))&&( constStmts > 0 )) {
this_object_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_WAIT_FOR||LA(1)==KW_WAIT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&(
(sym.canLoadClass(LT(2).getText()) ||
isObjectType(resolveLvalueCoreType(2, false)) ||
LA(2) == KW_THIS_OBJ ||
LA(2) == KW_SUPER) &&
LA(3) == COLON &&
!followedByWhitespace(LT(3))
)) {
wait_for_dotnet_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_WAIT_FOR||LA(1)==KW_WAIT) && (_tokenSet_108.member(LA(2))) && (_tokenSet_109.member(LA(3)))) {
wait_for_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_110.member(LA(1))) && (_tokenSet_111.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
embedded_sql();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = stmt_list_AST;
}
/**
* Matches the <code>ACCUMULATE</code> language statement. Calls the {@link #expr} and an
* {@link #aggregate_phrase}. It is an undocmented feature of the the 4GL that the aggregate phrase is
* optional. Another undocumented feature of the 4GL is that there can be an optional {@link #format_string}
* rule to follow the aggregate phrase.
* <p>
* Depending on the accumulator type there is an undocumented feature of the 4GL where the data can be
* read and even assigned directly as an lvalue! The parser creates variables to match this feature.
* <p>
* <pre>
* Accumulator Type Variable Name Variable Type
* ------------------ ------------- -------------
* KW_COUNT count VAR_INT
* KW_SUB_CNT count VAR_INT
* KW_TOTAL total VAR_DEC
* KW_SUB_TOT total VAR_DEC
* KW_MIN min VAR_DEC
* KW_SUB_MIN min VAR_DEC
* KW_MAX max VAR_DEC
* KW_SUB_MAX max VAR_DEC
* KW_AVERAGE avg VAR_DEC
* KW_SUB_AVG avg VAR_DEC
* </pre>
* <p>
* Used by {@link #stmt_list}.
*/
public final void accumulate_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast accumulate_stmt_AST = null;
Aast a_AST = null;
try { // for error handling
Aast tmp577_AST = null;
tmp577_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp577_AST);
match(KW_ACCUM);
{
int _cnt712=0;
_loop712:
do {
if ((_tokenSet_24.member(LA(1)))) {
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&(
preScanPass == 0 || !sym.isField(LT(1).getText())
)) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==LPARENS) && (_tokenSet_75.member(LA(2))) && (_tokenSet_112.member(LA(3)))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
aggregate_phrase();
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
if ( _cnt712>=1 ) { break _loop712; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt712++;
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
if (a_AST != null)
{
Aast child = a_AST.getChildAt(0);
int ttype = child.getType();
if (ttype == KW_COUNT || ttype == KW_SUB_CNT)
{
sym.addAccumVariable("count", VAR_INT);
}
else if (ttype == KW_TOTAL || ttype == KW_SUB_TOT)
{
sym.addAccumVariable("total", VAR_DEC);
}
else if (ttype == KW_MIN || ttype == KW_SUB_MIN)
{
sym.addAccumVariable("min", VAR_DEC);
}
else if (ttype == KW_MAX || ttype == KW_SUB_MAX)
{
sym.addAccumVariable("max", VAR_DEC);
}
else if (ttype == KW_AVERAGE || ttype == KW_SUB_AVG)
{
sym.addAccumVariable("avg", VAR_DEC);
}
}
accumulate_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = accumulate_stmt_AST;
}
/**
* Matches the <code>APPLY</code> language statement. Calls the
* {@link #expr} and {@link #to_event_target} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void apply_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast apply_stmt_AST = null;
try { // for error handling
Aast tmp578_AST = null;
tmp578_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp578_AST);
match(KW_APPLY);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TO:
{
to_event_target();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
apply_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = apply_stmt_AST;
}
/**
* Matches an <code>ASSIGN</code> Progress 4GL language statement.
* This is the statement that either moves data from screen buffers to an
* lvalue OR it handles multiple regular assignments as a single block,
* eliminating any overhead associated with each assignment until the entire
* set is complete (e.g. rebuilding an index).
* <p>
* It is undocumented, but the assign statement can be empty (just the
* assign keyword followed by a dot).
* <p>
* The syntax is differentiated from a top level {@link #assignment} statement
* by:
* <ul>
* <li> the <code>ASSIGN</code> keyword as the first token
* <li> the requirement that there be an lvalue and assignment operator
* before any expression rather than being optional as in the
* top level assignment rule
* <li> only one terminating <code>DOT</code>
* </ul>
* <p>
* A rule reference called {@link #assign} is used to implement the
* assignment logic. Note that this is <b>nearly identical</b> to the
* <code>assignment</code> rule except for the non-mandatory lvalue and
* assignment operator and the lack of the terminating <code>DOT</code>.
* Due to these differences, the <code>assignment</code> rule could not be
* reused here.
* <p>
* Uses a separate rule for core logic allows ANTLR's natural tree building to
* generate a proper result (the entire subtree created by <code>assign</code>
* is added as a child of the <code>ASSIGN</code> keyword).
* <p>
* Uses {@link #record_spec}, {@link #assign} and {@link #simple_when_clause}.
* <p>
* This rule has inherent ambiguity between the record form and the field
* form. This is resolved by precedence. A test for whether the 1st token
* is a table reference is made, if it matches a table reference, then the
* record form is matched.
* <p>
* ANTLR reports bogus ambiguity in the use of the browse reference but
* warnings have been disabled since this is not ambiguous.
*/
public final void assign_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assign_stmt_AST = null;
try { // for error handling
{
Aast tmp579_AST = null;
tmp579_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp579_AST);
match(KW_ASSIGN);
{
if (((_tokenSet_13.member(LA(1))) && (LA(2)==DOT||LA(2)==KW_EXCEPT||LA(2)==KW_NO_ERROR) && (_tokenSet_11.member(LA(3))))&&(
isRecord(LT(1).getText()) &&
!isQualifiedFieldNameQuirk(LT(1), LT(2), LT(3))
)) {
record_spec(null);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_NO_ERROR )) {
{
int _cnt669=0;
_loop669:
do {
if (((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_NO_ERROR )) {
assign();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_WHEN) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
simple_when_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_113.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
if ( _cnt669>=1 ) { break _loop669; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt669++;
} while (true);
}
}
else if ((LA(1)==DOT||LA(1)==KW_NO_ERROR) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp580_AST = null;
tmp580_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp580_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
assign_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = assign_stmt_AST;
}
/**
* Matches the <code>KW_BLK_LVL</code> keyword with a following {@link #on_event_phrase}.
*/
public final void block_level_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast block_level_stmt_AST = null;
try { // for error handling
Aast tmp581_AST = null;
tmp581_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp581_AST);
match(KW_BLK_LVL);
on_event_phrase();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
block_level_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = block_level_stmt_AST;
}
/**
* Matches the <code>BUFFER-COMPARE and BUFFER-COPY</code> language statements
* and all following constructs.
* <p>
* <ul>
* <li> {@link #record}
* <li> {@link #buffer_modification_list}
* <li> {@link #to_target}
* <li> {@link #save_result_in} (compare only)
* <li> {@link #explicit_compares} (compare only)
* <li> {@link #sub_assign_clause} (copy only)
* </ul>
* <p>
* Used by {@link #stmt_list}.
* <p>
* Bogus ANTLR ambiguity warnings are disabled.
*/
public final void buffer_compare_or_copy_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast buffer_compare_or_copy_stmt_AST = null;
try { // for error handling
boolean compare = true;
NameNode nothing = null;
{
{
switch ( LA(1)) {
case KW_BUF_COMP:
{
Aast tmp582_AST = null;
tmp582_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp582_AST);
match(KW_BUF_COMP);
break;
}
case KW_BUF_COPY:
{
Aast tmp583_AST = null;
tmp583_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp583_AST);
match(KW_BUF_COPY);
compare = false;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
nothing=record(true, true, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_EXCEPT:
case KW_USING:
{
buffer_modification_list();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TO:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
to_target();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1255:
do {
switch ( LA(1)) {
case KW_CASE_SEN:
{
Aast tmp584_AST = null;
tmp584_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp584_AST);
match(KW_CASE_SEN);
break;
}
case KW_BINARY:
{
Aast tmp585_AST = null;
tmp585_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp585_AST);
match(KW_BINARY);
break;
}
case KW_NO_LOBS:
{
Aast tmp586_AST = null;
tmp586_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp586_AST);
match(KW_NO_LOBS);
break;
}
default:
if (((_tokenSet_114.member(LA(1))) && (_tokenSet_115.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( compare )) {
{
switch ( LA(1)) {
case KW_SAVE:
{
save_result_in();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_ERROR:
case KW_COMPARES:
case KW_EXPLICIT:
case COLON:
{
explicit_compares();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((LA(1)==KW_ASSIGN))&&( !compare )) {
sub_assign_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1255;
}
}
} while (true);
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp587_AST = null;
tmp587_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp587_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
buffer_compare_or_copy_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = buffer_compare_or_copy_stmt_AST;
}
/**
* Matches the <code>CALL</code> language statement, the required
* {@link #filename} of the invoked HLC (host language call) function and
* and optional list of {@link #expr} (arguments). Used by {@link #stmt_list}.
*/
public final void call_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast call_stmt_AST = null;
try { // for error handling
Aast tmp588_AST = null;
tmp588_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp588_AST);
match(KW_CALL);
filename(null);
astFactory.addASTChild(currentAST, returnAST);
{
_loop1618:
do {
if ((_tokenSet_24.member(LA(1)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1618;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
call_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = call_stmt_AST;
}
/**
* Matches the <code>CASE</code> language statement. This rule uses rule references {@link #when_clause},
* {@link #otherwise} and {@link #end_stmt} to properly build the AST. The END is optional if the CASE
* is the last statement in the file.
* <p>
* Used by {@link #stmt_list}.
*/
public final void case_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast case_stmt_AST = null;
try { // for error handling
Aast tmp589_AST = null;
tmp589_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp589_AST);
match(KW_CASE);
expr();
astFactory.addASTChild(currentAST, returnAST);
block_term();
astFactory.addASTChild(currentAST, returnAST);
{
_loop495:
do {
if ((LA(1)==KW_WHEN) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
when_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop495;
}
} while (true);
}
{
if ((LA(1)==KW_OTHER) && (_tokenSet_10.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
otherwise();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != EOF )) {
end_stmt(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
case_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = case_stmt_AST;
}
/**
* Implements a <code>KW_CATCH</code> block which is part of the structured
* error handling added in 10.2x. This uses the {@link #symbol},
* {@link #as_clause}, {@link #block} and {@link #end_stmt} sub-rules to
* match and build the tree. The tree will be rooted at the
* <code>KW_CATCH</code> node. Variable and schema scopes are pushed and
* popped in this statement.
*/
public final void catch_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast catch_stmt_AST = null;
Token cat = null;
Aast cat_AST = null;
Aast e_AST = null;
Aast b_AST = null;
try { // for error handling
{
cat = LT(1);
cat_AST = (Aast)astFactory.create(cat);
astFactory.makeASTRoot(currentAST, cat_AST);
match(KW_CATCH);
symbol();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
as_clause(e_AST.getText(), false);
astFactory.addASTChild(currentAST, returnAST);
block_term();
astFactory.addASTChild(currentAST, returnAST);
// this normally sets parsed options into the Variable instance
// in the symbol resolver; but in this case it just ensures some
// metadata is set properly
sym.setVariableOptions(e_AST.getText(), cat_AST);
// this will save some of the metadata state into the catch node
// as annotations, but the normal options processing is not needed
sym.annotateVariableOptions(e_AST.getText(), cat_AST, true);
block();
b_AST = (Aast)returnAST;
if (b_AST == null)
{
b_AST = (Aast)astFactory.make( (new ASTArray(1)).add((Aast)astFactory.create(BLOCK,"block")));
}
else
{
b_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST));
}
cat_AST.addChild(b_AST);
end_stmt(true);
astFactory.addASTChild(currentAST, returnAST);
}
catch_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = catch_stmt_AST;
}
/**
* Matches the <code>CHOOSE</code> language statement, the required following
* {@link #choose_row_or_field_list} and all possible options (which can be
* specified in any order).
* <p>
* Calls:
* <p>
* <ul>
* <li> {@link #choose_keys_clause}
* <li> {@link #go_on_clause}
* <li> {@link #pause_clause}
* <li> {@link #simple_color_clause}
* <li> {@link #frame_phrase}
* </ul>
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Used by {@link #choose_stmt}.
*/
public final void choose_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast choose_stmt_AST = null;
try { // for error handling
Aast tmp590_AST = null;
tmp590_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp590_AST);
match(KW_CHOOSE);
choose_row_or_field_list();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1498:
do {
switch ( LA(1)) {
case KW_AUTO_RET:
{
Aast tmp591_AST = null;
tmp591_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp591_AST);
match(KW_AUTO_RET);
break;
}
case KW_NO_ERROR:
{
Aast tmp592_AST = null;
tmp592_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp592_AST);
match(KW_NO_ERROR);
break;
}
case KW_KEYS:
{
choose_keys_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_GO_ON:
{
go_on_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PAUSE:
{
pause_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_COLOR:
{
simple_color_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_WITH:
{
frame_phrase(false, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1498;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
choose_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = choose_stmt_AST;
}
/**
* Matches the <code>CLEAR</code> language statement.
* <p>
* Used by {@link #stmt_list}.
*/
public final void clear_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast clear_stmt_AST = null;
try { // for error handling
Aast tmp593_AST = null;
tmp593_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp593_AST);
match(KW_CLEAR);
{
switch ( LA(1)) {
case KW_FRAME:
{
frame_reference(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ALL:
case KW_NO_PAUSE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_ALL:
{
Aast tmp594_AST = null;
tmp594_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp594_AST);
match(KW_ALL);
break;
}
case DOT:
case KW_NO_PAUSE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_PAUSE:
{
Aast tmp595_AST = null;
tmp595_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp595_AST);
match(KW_NO_PAUSE);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
clear_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = clear_stmt_AST;
}
/**
* Matches a <code>CLOSE QUERY</code> language statement and the required
* following query name (see {@link #malformed_symbol}).
* <p>
* Used by {@link #stmt_list}.
*/
public final void close_query_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast close_query_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token qk = null;
Aast qk_AST = null;
Aast q_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CLOSE);
c_AST.setType(CLOSE_QUERY);
qk = LT(1);
qk_AST = (Aast)astFactory.create(qk);
match(KW_QUERY);
hide(qk);
malformed_symbol();
q_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
q_AST.setType(QUERY);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
close_query_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = close_query_stmt_AST;
}
/**
* Matches the <code>CLOSE STORED-PROCEDURE</code> language statement, the
* following {@link #reserved_or_symbol}, the optional {@link #assign}
* and optional {@link #where_clause}. The result will be rooted at a
* <code>CLOSE_STORED_PROCEDURE</code> node. Called from {@link #stmt_list}.
* <p>
* Warning: this is an early implementation which does not yet support the
* notion that a stored procedure is like a special kind of table type. The
* stored procedure is a schema object created in the database supported
* by a 4GL data server. That schema object is known to the 4GL and it
* is called with optional parameters (and must be closed when done). But
* to get the data out of the results, Progress creates a buffer of the same
* name as the procedure, which can be used in record phrases to read the
* data. Likewise, there are properties defined for the results which are
* treated like fields. The schema dictionary, symbol resolver and parser
* all need updates to fully support this new resource. It is likely that
* real 4GL code using these constructs will not parse properly at this time.
*/
public final void close_stored_proc_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast close_stored_proc_stmt_AST = null;
Token r = null;
Aast r_AST = null;
Token sp = null;
Aast sp_AST = null;
try { // for error handling
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.makeASTRoot(currentAST, r_AST);
match(KW_CLOSE);
r_AST.setType(CLOSE_STORED_PROCEDURE);
sp = LT(1);
sp_AST = (Aast)astFactory.create(sp);
match(KW_STORPROC);
hide(sp);
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_64.member(LA(1)))) {
assign_proc_handle();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_WHERE)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_WHERE:
{
where_clause(true);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
close_stored_proc_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = close_stored_proc_stmt_AST;
}
/**
* Matches the <code>COMPILE</code> language statement.
* <p>
* Calls {@link #external_name_spec} and {@link #compile_options_clause}
* rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void compile_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast compile_stmt_AST = null;
try { // for error handling
Aast tmp596_AST = null;
tmp596_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp596_AST);
match(KW_COMPILE);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
{
_loop681:
do {
if ((_tokenSet_116.member(LA(1)))) {
compile_options_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop681;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
compile_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = compile_stmt_AST;
}
/**
* Matches a <code>CONNECT</code> language statement, the following
* {@link #database_name} and arbitrary connect options.
* <p>
* Used by {@link #stmt_list}.
*/
public final void connect_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast connect_stmt_AST = null;
try { // for error handling
Aast tmp597_AST = null;
tmp597_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp597_AST);
match(KW_CONN);
{
if ((((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LT(1).getText().startsWith("-") == false )) {
database_name(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= DOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
connect_options();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp598_AST = null;
tmp598_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp598_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
connect_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = connect_stmt_AST;
}
/**
* Matches the <code>COPY-LOB</code> language statement.
* <p>
* Calls {@link #from_lob_source}, {@link #to_lob_target} and {@link #codepage_convert_phrase}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void copy_lob_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast copy_lob_stmt_AST = null;
try { // for error handling
Aast tmp599_AST = null;
tmp599_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp599_AST);
match(KW_CPY_LOB);
from_lob_source();
astFactory.addASTChild(currentAST, returnAST);
to_lob_target();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_CONVERT:
case KW_NO_CVT:
{
codepage_convert_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp600_AST = null;
tmp600_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp600_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
copy_lob_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = copy_lob_stmt_AST;
}
/**
* Matches a <code>CREATE ALIAS</code> language statement, and the following
* database names (see {@link #database_name}).
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_alias_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_alias_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token al = null;
Aast al_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_ALIAS);
al = LT(1);
al_AST = (Aast)astFactory.create(al);
match(KW_ALIAS);
hide(al);
database_name(false);
astFactory.addASTChild(currentAST, returnAST);
Aast tmp601_AST = null;
tmp601_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp601_AST);
match(KW_FOR);
Aast tmp602_AST = null;
tmp602_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp602_AST);
match(KW_DATABASE);
database_name(false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp603_AST = null;
tmp603_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp603_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_alias_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_alias_stmt_AST;
}
/**
* Matches a <code>CREATE BROWSE</code> language statement, and the
* following options.
* <p>
* Uses:
* <p>
* <ul>
* <li> {@link #handle}
* <li> {@link #in_widget_pool_clause}
* <li> {@link #attribute_assign_clause}
* <li> {@link #trigger_phrase}
* </ul>
* <p>
* Used by {@link #stmt_list}.
* <p>
* Allows the undocumented usage of <code>KW_NO_ERROR</code> after the
* <code>in_widget_pool_clause</code> and before the <code>attribute_assign_clause</code>,
* which was found in working 4GL code.
*/
public final void create_browse_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_browse_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token br = null;
Aast br_AST = null;
boolean allowColon = false;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_BROWSE);
br = LT(1);
br_AST = (Aast)astFactory.create(br);
match(KW_BROWSE);
hide(br);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ASSIGN:
case KW_NO_ERROR:
case KW_TRIGGERS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp604_AST = null;
tmp604_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp604_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
case KW_ASSIGN:
case KW_TRIGGERS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_ASSIGN:
{
attribute_assign_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_TRIGGERS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_TRIGGERS:
{
trigger_phrase();
astFactory.addASTChild(currentAST, returnAST);
allowColon = true;
break;
}
case DOT:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==COLON))&&( allowColon )) {
colon();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
create_browse_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_browse_stmt_AST;
}
/**
* Matches a <code>CREATE BUFFER</code> language statement, the required
* following {@link #handle}, the required <code>FOR TABLE</code>
* construct (see {@link #for_table_clause}) and the optional
* {@link #in_widget_pool_clause} and {@link #buffer_name_clause} rules.
* <p>
* An undocumented feature was found where the <code>NO-ERROR</code> keyword
* can be added at the end of this statement.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_buffer_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_buffer_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token bu = null;
Aast bu_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_BUFFER);
bu = LT(1);
bu_AST = (Aast)astFactory.create(bu);
match(KW_BUFFER);
hide(bu);
handle();
astFactory.addASTChild(currentAST, returnAST);
for_table_clause();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1245:
do {
switch ( LA(1)) {
case KW_BUF_NAME:
{
buffer_name_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1245;
}
}
} while (true);
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp605_AST = null;
tmp605_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp605_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_buffer_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_buffer_stmt_AST;
}
/**
* Matches a <code>CREATE CALL</code> language statement, the required
* following {@link #handle} and the optional {@link #in_widget_pool_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_call_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_call_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token ca = null;
Aast ca_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_CALL);
ca = LT(1);
ca_AST = (Aast)astFactory.create(ca);
match(KW_CALL);
hide(ca);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp606_AST = null;
tmp606_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp606_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_call_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_call_stmt_AST;
}
/**
* Matches a <code>CREATE CLIENT-PRINCIPAL</code> language statement and the
* required following {@link #handle}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_client_principal_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_client_principal_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token cp = null;
Aast cp_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
cp = LT(1);
cp_AST = (Aast)astFactory.create(cp);
match(KW_CLNT_PRL);
hide(cp); c_AST.setType(CREATE_CLIENT_PRINCIPAL);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp607_AST = null;
tmp607_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp607_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_client_principal_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_client_principal_stmt_AST;
}
/**
* Matches a <code>CREATE DATABASE</code> language statement, the required
* following expressions and the optional <code>REPLACE or NO-ERROR</code>
* keywords.
* <p>
* Uses {@link #expr} and {@link #from_database_clause} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_database_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_database_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token db = null;
Aast db_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_DATABASE);
db = LT(1);
db_AST = (Aast)astFactory.create(db);
match(KW_DATABASE);
hide(db);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_FROM:
{
from_database_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
case KW_REPLACE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop1232:
do {
switch ( LA(1)) {
case KW_REPLACE:
{
Aast tmp608_AST = null;
tmp608_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp608_AST);
match(KW_REPLACE);
break;
}
case KW_NO_ERROR:
{
Aast tmp609_AST = null;
tmp609_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp609_AST);
match(KW_NO_ERROR);
break;
}
default:
{
break _loop1232;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_database_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_database_stmt_AST;
}
/**
* Matches a <code>CREATE DATASET</code> language statement, the required
* following {@link #handle} and the optional {@link #in_widget_pool_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_dataset_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_dataset_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token ds = null;
Aast ds_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_DATASET);
ds = LT(1);
ds_AST = (Aast)astFactory.create(ds);
match(KW_DATASET);
hide(ds);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_dataset_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_dataset_stmt_AST;
}
/**
* Matches a <code>CREATE DATA-SOURCE</code> language statement, the required
* following {@link #handle} and the optional {@link #in_widget_pool_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_datasource_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_datasource_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token ds = null;
Aast ds_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_DATA_SOURCE);
ds = LT(1);
ds_AST = (Aast)astFactory.create(ds);
match(KW_DATA_SRC);
hide(ds);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_datasource_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_datasource_stmt_AST;
}
/**
* Matches a <code>CREATE QUERY</code> language statement, the required
* following {@link #handle} and the optional {@link #in_widget_pool_clause}.
* <p>
* An undocumented feature was found where the <code>NO-ERROR</code> keyword
* can be added at the end of this statement.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_query_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_query_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token qr = null;
Aast qr_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_QUERY);
qr = LT(1);
qr_AST = (Aast)astFactory.create(qr);
match(KW_QUERY);
hide(qr);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp610_AST = null;
tmp610_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp610_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_query_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_query_stmt_AST;
}
/**
* Matches a <code>CREATE SAX-READER</code>, <code>CREATE SAX-WRITER</code>
* and <code>CREATE SAX-ATTRIBUTES</code> language statements and the required
* following {@link #handle}. Also uses {@link #in_widget_pool_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_sax_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_sax_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token sa = null;
Aast sa_AST = null;
Token sr = null;
Aast sr_AST = null;
Token sw = null;
Aast sw_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
{
switch ( LA(1)) {
case KW_SAX_ATTR:
{
sa = LT(1);
sa_AST = (Aast)astFactory.create(sa);
match(KW_SAX_ATTR);
hide(sa); c_AST.setType(CREATE_SAX_ATTRIBUTES);
break;
}
case KW_SAX_READ:
{
sr = LT(1);
sr_AST = (Aast)astFactory.create(sr);
match(KW_SAX_READ);
hide(sr); c_AST.setType(CREATE_SAX_READER);
break;
}
case KW_SAX_WRIT:
{
sw = LT(1);
sw_AST = (Aast)astFactory.create(sw);
match(KW_SAX_WRIT);
hide(sw); c_AST.setType(CREATE_SAX_WRITER);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp611_AST = null;
tmp611_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp611_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_sax_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_sax_stmt_AST;
}
/**
* Matches a <code>CREATE SERVER</code> language statement, the following
* {@link #handle} and the optional {@link #attribute_assign_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_server_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_server_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token se = null;
Aast se_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_SERVER);
se = LT(1);
se_AST = (Aast)astFactory.create(se);
match(KW_SERVER);
hide(se);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_ASSIGN:
{
attribute_assign_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_server_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_server_stmt_AST;
}
/**
* Matches a <code>CREATE SOAP-HEADER</code> language statement, and the
* following options.
* <p>
* Uses:
* <p>
* <ul>
* <li> {@link #handle}
* <li> {@link #in_widget_pool_clause}
* </ul>
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_soap_header_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_soap_header_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token so = null;
Aast so_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_SOAP_HEADER);
so = LT(1);
so_AST = (Aast)astFactory.create(so);
match(KW_SOAP_HDR);
hide(so);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_soap_header_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_soap_header_stmt_AST;
}
/**
* Matches a <code>CREATE SOAP-HEADER</code> language statement, and the
* following options.
* <p>
* Uses:
* <p>
* <ul>
* <li> {@link #handle}
* <li> {@link #in_widget_pool_clause}
* </ul>
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_soap_header_entryref_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_soap_header_entryref_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token so = null;
Aast so_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_SOAP_HEADER_ENTRYREF);
so = LT(1);
so_AST = (Aast)astFactory.create(so);
match(KW_SOAP_HER);
hide(so);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_soap_header_entryref_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_soap_header_entryref_stmt_AST;
}
/**
* Matches a <code>CREATE SERVER-SOCKET or CREATE SOCKET</code> language
* statements and the required following {@link #handle}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_socket_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_socket_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token ss = null;
Aast ss_AST = null;
Token so = null;
Aast so_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
{
switch ( LA(1)) {
case KW_SRV_SOCK:
{
ss = LT(1);
ss_AST = (Aast)astFactory.create(ss);
match(KW_SRV_SOCK);
hide(ss); c_AST.setType(CREATE_SRV_SOCKET);
break;
}
case KW_SOCKET:
{
so = LT(1);
so_AST = (Aast)astFactory.create(so);
match(KW_SOCKET);
hide(so); c_AST.setType(CREATE_SOCKET);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp612_AST = null;
tmp612_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp612_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_socket_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_socket_stmt_AST;
}
/**
* Matches a <code>CREATE TEMP-TABLE</code> language statement, the required
* following handle variable/field and the optional
* {@link #in_widget_pool_clause}. The {@link #lvalue} rule and a validating
* semantic predicate are used to match the handle.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_temp_table_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_temp_table_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token tt = null;
Aast tt_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_TEMP_TABLE);
tt = LT(1);
tt_AST = (Aast)astFactory.create(tt);
match(KW_TEMP_TAB);
hide(tt);
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp613_AST = null;
tmp613_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp613_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_temp_table_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_temp_table_stmt_AST;
}
/**
* Matches a <code>CREATE WIDGET-POOL</code> language statement, and the
* following optional {@link #expr} and/or <code>KW_PERSIST</code>. It is
* undocumented, but working 4GL code shows that it is possible to match the
* <code>KW_PERSIST</code> for an unnamed pool (where there is no preceding
* <code>expr</code>).
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_widget_pool_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_widget_pool_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token wp = null;
Aast wp_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_WIDGET_POOL);
wp = LT(1);
wp_AST = (Aast)astFactory.create(wp);
match(KW_WID_POOL);
hide(wp);
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_PERSIST && LA(1) != KW_NO_ERROR )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_NO_ERROR||LA(1)==KW_PERSIST) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_PERSIST:
{
Aast tmp614_AST = null;
tmp614_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp614_AST);
match(KW_PERSIST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp615_AST = null;
tmp615_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp615_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_widget_pool_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_widget_pool_stmt_AST;
}
/**
* Matches a <code>CREATE X-DOCUMENT or CREATE X-NODEREF</code> language
* statements and the required following {@link #handle}. Working code has
* been found that allows a <code>KW_NO_ERROR</code> to optionally be present
* (in both statements) and this undocumented feature is supported here.
* Also uses {@link #in_widget_pool_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void create_xml_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_xml_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token xd = null;
Aast xd_AST = null;
Token xn = null;
Aast xn_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
{
switch ( LA(1)) {
case KW_X_DOC:
{
xd = LT(1);
xd_AST = (Aast)astFactory.create(xd);
match(KW_X_DOC);
hide(xd); c_AST.setType(CREATE_X_DOCUMENT);
break;
}
case KW_X_NODE:
{
xn = LT(1);
xn_AST = (Aast)astFactory.create(xn);
match(KW_X_NODE);
hide(xn); c_AST.setType(CREATE_X_NODEREF);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
handle();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp616_AST = null;
tmp616_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp616_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_xml_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_xml_stmt_AST;
}
/**
* Matches the <code>CREATE</code> language statement and implements all
* following options. Calls the {@link #record} and {@link #using_id_clause}
* rules. Called by the {@link #stmt_list} rule.
*/
public final void create_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_stmt_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp617_AST = null;
tmp617_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp617_AST);
match(KW_CREATE);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_USING:
{
using_id_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp618_AST = null;
tmp618_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp618_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
create_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_stmt_AST;
}
/**
* Matches a <code>CREATE widget_type</code> or <code>CREATE automation-object</code>language
* statement, and the following options. The types of widgets supported are:
* <p>
* <ul>
* <li> BUTTON
* <li> COMBO-BOX
* <li> CONTROL-FRAME
* <li> DIALOG-BOX
* <li> EDITOR
* <li> FILL-IN
* <li> FRAME
* <li> IMAGE
* <li> MENU
* <li> MENU-ITEM
* <li> RADIO-SET
* <li> RECTANGLE
* <li> SELECTION-LIST
* <li> SLIDER
* <li> SMTP-EMAIL (FWD extension)
* <li> SUB-MENU
* <li> TEXT
* <li> TIMER (FWD extension)
* <li> TOGGLE-BOX
* <li> WINDOW
* </ul>
* <p>
* Uses:
* <p>
* <ul>
* <li> {@link #lvalue}
* <li> {@link #in_widget_pool_clause}
* <li> {@link #sub_assign_clause}
* <li> {@link #trigger_phrase}
* </ul>
* <p>
* Used by {@link #stmt_list}.
* <p>
* Allows the undocumented usage of <code>KW_NO_ERROR</code> after the
* <code>in_widget_pool_clause</code> and before the <code>attribute_assign_clause</code>,
* which was found in working 4GL code.
*/
public final void create_widget_or_object_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_widget_or_object_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Aast h_AST = null;
boolean is_com_handle = false;
boolean is_widget = false;
boolean allowColon = false;
boolean is_timer_extension = false;
boolean is_smtp_email = false;
boolean is_report = false;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_WIDGET);
{
if ((LA(1)==KW_BUTTON) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp619_AST = null;
tmp619_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp619_AST);
match(KW_BUTTON);
is_widget = true;
}
else if ((LA(1)==KW_CHART) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp620_AST = null;
tmp620_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp620_AST);
match(KW_CHART);
is_widget = true;
}
else if ((LA(1)==KW_COMBO_BX) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp621_AST = null;
tmp621_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp621_AST);
match(KW_COMBO_BX);
is_widget = true;
}
else if ((LA(1)==KW_CNTRL_FR) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp622_AST = null;
tmp622_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp622_AST);
match(KW_CNTRL_FR);
is_widget = true;
}
else if ((LA(1)==KW_DIALOG) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp623_AST = null;
tmp623_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp623_AST);
match(KW_DIALOG);
is_widget = true;
}
else if ((LA(1)==KW_CALENDAR) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp624_AST = null;
tmp624_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp624_AST);
match(KW_CALENDAR);
is_widget = true;
}
else if ((LA(1)==KW_EDITOR) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp625_AST = null;
tmp625_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp625_AST);
match(KW_EDITOR);
is_widget = true;
}
else if ((LA(1)==KW_FILL_IN) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp626_AST = null;
tmp626_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp626_AST);
match(KW_FILL_IN);
is_widget = true;
}
else if ((LA(1)==KW_FRAME) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp627_AST = null;
tmp627_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp627_AST);
match(KW_FRAME);
is_widget = true;
}
else if ((LA(1)==KW_HTML_BWS) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp628_AST = null;
tmp628_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp628_AST);
match(KW_HTML_BWS);
is_widget = true;
}
else if ((LA(1)==KW_IMAGE) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp629_AST = null;
tmp629_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp629_AST);
match(KW_IMAGE);
is_widget = true;
}
else if ((LA(1)==KW_IL_IMG) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp630_AST = null;
tmp630_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp630_AST);
match(KW_IL_IMG);
is_widget = true;
}
else if ((LA(1)==KW_MENU) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp631_AST = null;
tmp631_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp631_AST);
match(KW_MENU);
is_widget = true;
}
else if ((LA(1)==KW_MENU_ITM) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp632_AST = null;
tmp632_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp632_AST);
match(KW_MENU_ITM);
is_widget = true;
}
else if ((LA(1)==KW_PROG_BAR) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp633_AST = null;
tmp633_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp633_AST);
match(KW_PROG_BAR);
is_widget = true;
}
else if ((LA(1)==KW_RADIO_S) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp634_AST = null;
tmp634_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp634_AST);
match(KW_RADIO_S);
is_widget = true;
}
else if ((LA(1)==KW_RECT) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp635_AST = null;
tmp635_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp635_AST);
match(KW_RECT);
is_widget = true;
}
else if ((LA(1)==KW_SEL_LST) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp636_AST = null;
tmp636_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp636_AST);
match(KW_SEL_LST);
is_widget = true;
}
else if ((LA(1)==KW_SIGNATUR) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp637_AST = null;
tmp637_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp637_AST);
match(KW_SIGNATUR);
is_widget = true;
}
else if ((LA(1)==KW_SLIDER) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp638_AST = null;
tmp638_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp638_AST);
match(KW_SLIDER);
is_widget = true;
}
else if ((LA(1)==KW_SPRSHEET) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp639_AST = null;
tmp639_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp639_AST);
match(KW_SPRSHEET);
is_widget = true;
}
else if ((LA(1)==KW_SUB_MENU) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp640_AST = null;
tmp640_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp640_AST);
match(KW_SUB_MENU);
is_widget = true;
}
else if ((LA(1)==KW_TABSET) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp641_AST = null;
tmp641_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp641_AST);
match(KW_TABSET);
is_widget = true;
}
else if ((LA(1)==KW_TEXT) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp642_AST = null;
tmp642_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp642_AST);
match(KW_TEXT);
is_widget = true;
}
else if ((LA(1)==KW_TOGGL_BX) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp643_AST = null;
tmp643_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp643_AST);
match(KW_TOGGL_BX);
is_widget = true;
}
else if ((LA(1)==KW_TREELIST) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp644_AST = null;
tmp644_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp644_AST);
match(KW_TREELIST);
is_widget = true;
}
else if ((LA(1)==KW_TREEVIEW) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp645_AST = null;
tmp645_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp645_AST);
match(KW_TREEVIEW);
is_widget = true;
}
else if ((LA(1)==KW_WINDOW) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp646_AST = null;
tmp646_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp646_AST);
match(KW_WINDOW);
is_widget = true;
}
else if ((LA(1)==KW_BTN_LIST) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp647_AST = null;
tmp647_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp647_AST);
match(KW_BTN_LIST);
is_widget = true;
}
else if ((LA(1)==KW_TIMER) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp648_AST = null;
tmp648_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp648_AST);
match(KW_TIMER);
is_timer_extension = true;
}
else if ((LA(1)==KW_SMTP_EML) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp649_AST = null;
tmp649_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp649_AST);
match(KW_SMTP_EML);
is_smtp_email = true;
}
else if ((LA(1)==KW_REPORT) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp650_AST = null;
tmp650_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp650_AST);
match(KW_REPORT);
is_report = true;
}
else if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
handle();
h_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (h_AST.getType() == VAR_COM_HANDLE ||
h_AST.getType() == FIELD_COM_HANDLE ||
(h_AST.getType() == SYS_HANDLE &&
h_AST.getAnnotation("oldtype") != null &&
((Long) h_AST.getAnnotation("oldtype")).intValue() == KW_COM_SELF))
{
if (is_widget)
{
// do not allow com-handle vars for create widget cases
throw new NoViableAltException(LT(0), getFilename());
}
c_AST.setType(CREATE_OBJECT);
is_com_handle = true;
}
if (is_timer_extension)
{
c_AST.setType(CREATE_TIMER);
}
if (is_smtp_email)
{
c_AST.setType(CREATE_SMTP_EMAIL);
}
if (is_report)
{
c_AST.setType(CREATE_REPORT);
}
}
{
if (((LA(1)==KW_CONN))&&( is_com_handle )) {
com_connect_option();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_117.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==KW_IN))&&( !is_com_handle && !is_timer_extension && !is_smtp_email && !is_report )) {
in_widget_pool_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_118.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp651_AST = null;
tmp651_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp651_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
case KW_ASSIGN:
case KW_TRIGGERS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==KW_ASSIGN))&&( !is_com_handle || is_timer_extension || is_smtp_email )) {
attribute_assign_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_TRIGGERS||LA(1)==COLON)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==KW_TRIGGERS))&&( (!is_com_handle && !is_smtp_email && !is_report) || is_timer_extension )) {
trigger_phrase();
astFactory.addASTChild(currentAST, returnAST);
allowColon = true;
}
else if ((LA(1)==DOT||LA(1)==COLON)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==COLON))&&( allowColon )) {
colon();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
create_widget_or_object_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = create_widget_or_object_stmt_AST;
}
/**
* Matches the <code>DDE ADVISE</code> language statement. There is always
* a following {@link #expr} and {@link #item_clause}. There is an optional
* use of {@link #time_clause}. Used by {@link #stmt_list}.
*/
public final void dde_advise_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_advise_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token ad = null;
Aast ad_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_ADVISE);
ad = LT(1);
ad_AST = (Aast)astFactory.create(ad);
match(KW_ADVISE);
hide(ad);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_START:
{
Aast tmp652_AST = null;
tmp652_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp652_AST);
match(KW_START);
break;
}
case KW_STOP:
{
Aast tmp653_AST = null;
tmp653_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp653_AST);
match(KW_STOP);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
item_clause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TIME:
{
time_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp654_AST = null;
tmp654_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp654_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_advise_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_advise_stmt_AST;
}
/**
* Matches the <code>DDE EXECUTE</code> language statement. There is always
* a following {@link #expr} and {@link #command_clause}. There is an
* optional use of {@link #time_clause}. Used by {@link #stmt_list}.
*/
public final void dde_execute_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_execute_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token exe = null;
Aast exe_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_EXECUTE);
exe = LT(1);
exe_AST = (Aast)astFactory.create(exe);
match(KW_EXECUTE);
hide(exe);
expr();
astFactory.addASTChild(currentAST, returnAST);
command_clause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TIME:
{
time_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp655_AST = null;
tmp655_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp655_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_execute_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_execute_stmt_AST;
}
/**
* Matches the <code>DDE GET</code> language statement. There is always
* a following {@link #expr}, {@link #source_or_target_clause} and
* {@link #item_clause}. There is an optional use of {@link #time_clause}.
* Used by {@link #stmt_list}.
*/
public final void dde_get_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_get_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token ge = null;
Aast ge_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_GET);
ge = LT(1);
ge_AST = (Aast)astFactory.create(ge);
match(KW_GET);
hide(ge);
expr();
astFactory.addASTChild(currentAST, returnAST);
source_or_target_clause(false);
astFactory.addASTChild(currentAST, returnAST);
item_clause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TIME:
{
time_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp656_AST = null;
tmp656_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp656_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_get_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_get_stmt_AST;
}
/**
* Matches the <code>DDE INITIATE</code> language statement. There is always
* a following {@link #expr}, {@link #frame_handle_clause},
* {@link #application_clause} and {@link #topic_clause}. Used by
* {@link #stmt_list}.
*/
public final void dde_initiate_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_initiate_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token in = null;
Aast in_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_INITIATE);
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INITIATE);
hide(in);
expr();
astFactory.addASTChild(currentAST, returnAST);
frame_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
application_clause();
astFactory.addASTChild(currentAST, returnAST);
topic_clause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp657_AST = null;
tmp657_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp657_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_initiate_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_initiate_stmt_AST;
}
/**
* Matches the <code>DDE REQUEST</code> language statement. There is always
* a following {@link #expr}, {@link #source_or_target_clause} and
* {@link #item_clause}. There is an optional use of {@link #time_clause}.
* Used by {@link #stmt_list}.
*/
public final void dde_request_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_request_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token re = null;
Aast re_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_REQUEST);
re = LT(1);
re_AST = (Aast)astFactory.create(re);
match(KW_REQUEST);
hide(re);
expr();
astFactory.addASTChild(currentAST, returnAST);
source_or_target_clause(false);
astFactory.addASTChild(currentAST, returnAST);
item_clause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TIME:
{
time_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp658_AST = null;
tmp658_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp658_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_request_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_request_stmt_AST;
}
/**
* Matches the <code>DDE SEND</code> language statement. There is always
* a following {@link #expr}, {@link #source_or_target_clause} and
* {@link #item_clause}. There is an optional use of {@link #time_clause}.
* Used by {@link #stmt_list}.
*/
public final void dde_send_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_send_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token se = null;
Aast se_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_SEND);
se = LT(1);
se_AST = (Aast)astFactory.create(se);
match(KW_SEND);
hide(se);
expr();
astFactory.addASTChild(currentAST, returnAST);
source_or_target_clause(false);
astFactory.addASTChild(currentAST, returnAST);
item_clause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TIME:
{
time_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp659_AST = null;
tmp659_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp659_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_send_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_send_stmt_AST;
}
/**
* Matches the <code>DDE TERMINATE</code> language statement. There is always
* a following {@link #expr}. Used by {@link #stmt_list}.
*/
public final void dde_terminate_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dde_terminate_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token te = null;
Aast te_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DDE);
d_AST.setType(DDE_TERMINATE);
te = LT(1);
te_AST = (Aast)astFactory.create(te);
match(KW_TERMINAT);
hide(te);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp660_AST = null;
tmp660_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp660_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
dde_terminate_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = dde_terminate_stmt_AST;
}
/**
* Matches a <code>DELETE ALIAS</code> language statement, and the following
* {@link #database_name}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void delete_alias_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_alias_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token al = null;
Aast al_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DELETE);
d_AST.setType(DELETE_ALIAS);
al = LT(1);
al_AST = (Aast)astFactory.create(al);
match(KW_ALIAS);
hide(al);
database_name(false);
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
delete_alias_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = delete_alias_stmt_AST;
}
/**
* Matches a <code>DELETE OBJECT</code> language statement, and the
* following required {@link #expr} which must resolve to a handle or an object
* reference. The fact that this is an expression is undocumented, the docs
* only state that this is a handle or an object, but customer code has shown
* it can be any expression.
* <p>
* Used by {@link #stmt_list}.
*/
public final void delete_object_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_object_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token ob = null;
Aast ob_AST = null;
boolean parens = false;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DELETE);
d_AST.setType(DELETE_OBJECT);
ob = LT(1);
ob_AST = (Aast)astFactory.create(ob);
match(KW_OBJECT);
hide(ob);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp661_AST = null;
tmp661_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp661_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
delete_object_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = delete_object_stmt_AST;
}
/**
* Matches a <code>DELETE PROCEDURE</code> language statement, and the
* following required {@link #expr}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void delete_procedure_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_procedure_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token pr = null;
Aast pr_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DELETE);
d_AST.setType(DELETE_PROCEDURE);
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PROC);
hide(pr);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp662_AST = null;
tmp662_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp662_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
delete_procedure_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = delete_procedure_stmt_AST;
}
/**
* Matches a <code>DELETE WIDGET</code> language statement, and the
* following required {@link #handle} (or list thereof).
* <p>
* Used by {@link #stmt_list}.
*/
public final void delete_widget_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_widget_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token wi = null;
Aast wi_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DELETE);
d_AST.setType(DELETE_WIDGET);
wi = LT(1);
wi_AST = (Aast)astFactory.create(wi);
match(KW_WIDGET);
hide(wi);
{
int _cnt1302=0;
_loop1302:
do {
if ((_tokenSet_85.member(LA(1)))) {
handle();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt1302>=1 ) { break _loop1302; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1302++;
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
delete_widget_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = delete_widget_stmt_AST;
}
/**
* Matches a <code>DELETE WIDGET-POOL</code> language statement, and the
* following optional {@link #expr}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void delete_widget_pool_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_widget_pool_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token wp = null;
Aast wp_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DELETE);
d_AST.setType(DELETE_WIDGET_POOL);
wp = LT(1);
wp_AST = (Aast)astFactory.create(wp);
match(KW_WID_POOL);
hide(wp);
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_NO_ERROR )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_NO_ERROR) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp663_AST = null;
tmp663_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp663_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
delete_widget_pool_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = delete_widget_pool_stmt_AST;
}
/**
* Matches the <code>DELETE</code> language statement and implements all
* following options. Calls the {@link #record} and {@link #validate} rules.
* Called by the {@link #stmt_list} rule.
*/
public final void delete_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_stmt_AST = null;
Aast r_AST = null;
Aast v_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp664_AST = null;
tmp664_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp664_AST);
match(KW_DELETE);
nothing=record(true, false, false);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_VALIDATE:
{
validate(null);
v_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp665_AST = null;
tmp665_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp665_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
delete_stmt_AST = (Aast)currentAST.root;
// if there is no explicit validation statement, create one using the schema-level
// validation defined for this table, if any
if (v_AST == null)
{
attachDeleteSchemaValidation(delete_stmt_AST, r_AST, sym);
}
delete_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = delete_stmt_AST;
}
/**
* Matches the <code>DISABLE TRIGGERS</code> statement, the qualifier for
* <code>DUMP or LOAD</code> and the associated {@link #record}. Used by
* {@link #stmt_list}.
*/
public final void disable_triggers_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast disable_triggers_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token tr = null;
Aast tr_AST = null;
Token f = null;
Aast f_AST = null;
Token of = null;
Aast of_AST = null;
try { // for error handling
NameNode nothing = null;
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DISABLE);
d_AST.setType(DISABLE_TRIGGERS);
tr = LT(1);
tr_AST = (Aast)astFactory.create(tr);
match(KW_TRIGGERS);
hide(tr);
f = LT(1);
f_AST = (Aast)astFactory.create(f);
match(KW_FOR);
hide(f);
{
switch ( LA(1)) {
case KW_DUMP:
{
Aast tmp666_AST = null;
tmp666_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp666_AST);
match(KW_DUMP);
break;
}
case KW_LOAD:
{
Aast tmp667_AST = null;
tmp667_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp667_AST);
match(KW_LOAD);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
of = LT(1);
of_AST = (Aast)astFactory.create(of);
match(KW_OF);
hide(of);
nothing=record(false, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_ALLW_REP:
{
Aast tmp668_AST = null;
tmp668_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp668_AST);
match(KW_ALLW_REP);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
disable_triggers_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = disable_triggers_stmt_AST;
}
/**
* Matches the <code>DISABLE</code> language statement. Calls the
* {@link #all_clause}, {@link #field_clause} and {@link #frame_phrase}.
* <p>
* The <code>UNLESS-HIDDEN</code> unreserved keyword naturally conflicts with
* the possible following lvalue. This is not really ambiguous so warnings
* have been disabled.
* <p>
* This supports an undocumented feature where there is no ALL keyword or field
* list. In such a case, this is thought to be a no-operation (at runtime).
* <p>
* Used by {@link #stmt_list}.
*/
public final void disable_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast disable_stmt_AST = null;
Aast fld_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
Aast tmp669_AST = null;
tmp669_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp669_AST);
match(KW_DISABLE);
{
if ((LA(1)==KW_UNL_HID) && (_tokenSet_104.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp670_AST = null;
tmp670_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp670_AST);
match(KW_UNL_HID);
}
else if ((_tokenSet_104.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_ALL:
{
all_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_WITH:
{
break;
}
default:
if ((_tokenSet_64.member(LA(1)))) {
{
int _cnt735=0;
_loop735:
do {
if ((_tokenSet_64.member(LA(1)))) {
field_clause(false);
fld_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
int type = fld_AST.getType();
if (type > BEGIN_FIELDTYPES && type < END_FIELDTYPES)
{
fields.add(fld_AST);
}
}
else {
if ( _cnt735>=1 ) { break _loop735; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt735++;
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
disable_stmt_AST = (Aast)currentAST.root;
String frameName = getFrameName(fp_AST);
if (!fields.isEmpty())
{
sym.addFrameFields(frameName, fields);
}
setUseDictExps(frameName, fp_AST, disable_stmt_AST);
disable_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = disable_stmt_AST;
}
/**
* Matches a <code>DISCONNECT</code> language statement, and the following
* {@link #database_name}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void disconnect_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast disconnect_stmt_AST = null;
try { // for error handling
Aast tmp671_AST = null;
tmp671_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp671_AST);
match(KW_DISCONN);
database_name(false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp672_AST = null;
tmp672_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp672_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
disconnect_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = disconnect_stmt_AST;
}
/**
* Matches the <code>DISPLAY</code> language statement and builds the associated AST.
* <p>
* The following list of rules are called to properly implement the tree building:
* <p>
* <ul>
* <li> {@link #lvalue} (for stream references)
* <li> {@link #space_or_skip}
* <li> {@link #expr}
* <li> {@link #format_phrase}
* <li> {@link #aggregate_phrase}
* <li> {@link #simple_when_clause}
* <li> {@link #at_base_field_clause}
* <li> {@link #frame_phrase}
* </ul>
* <p>
* The use of the format phrase following an expression is ambiguous since it includes rule
* references that include options that include expressions. Thus, the lookahead set for the
* format phrase is quite large and this naturally can conflict with following constructs in the
* form item's calling rule(s). A review of the code does not show any problems and no false
* positives have been encountered yet. Ambiguity warnings for this case have been disabled but
* this location bears watching. Similar ambiguities exist for the <code>UNLESS-HIDDEN</code>
* and aggregate phrase. These have been reviewed and the ambiguity warnings suppressed.
* <p>
* Another tricky part of this statement is resolving the ambiguity between the record and field
* specifications. The 4GL behavior is that records take precedence when there is a name
* conflict EXCEPT in the case where there are other form items specified. This means that
* records are disambiguated from fields by trying to do a table lookup, if it fails the record
* is not matched (see {@link #record_spec}) OR even when it is matched, we use lookahead to
* determine if there are any following form items (in which case it the table form is not
* matched). If the table is not matched, the {@link #expr} is checked. The careful ordering
* of these options and using a semantic predicate is needed to resolve the ambiguity. For this
* reason, ambiguity warnings have been disabled.
* <p>
* There is a bad hack in this rule to allow a various options that are supposed to follow the
* expression, be parsed in any order. Normally this is done by looping and making these peer
* alternatives BUT in this case, the format_phrase rule uses a loop internally and this
* generates hangs in the resulting parser. So, in this case, we only allow the format phrase
* to be executed once each time through the loop. This bypasses the hang. Nasty but it works.
* <p>
* Called by {@link #stmt_list}.
*/
public final void display_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast display_stmt_AST = null;
Aast s_AST = null;
Aast e_AST = null;
Aast fp_AST = null;
try { // for error handling
String symbolName = null;
Aast fld = null;
Set<Aast> fields = new HashSet<>();
String frame = "";
boolean isTableName = false;
boolean isFieldName = false;
boolean moreFollows = false;
boolean first = true;
Aast tmp673_AST = null;
tmp673_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp673_AST);
match(KW_DISP);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_77.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_UNL_HID) && (_tokenSet_77.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp674_AST = null;
tmp674_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp674_AST);
match(KW_UNL_HID);
}
else if ((_tokenSet_77.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
String nxt = LT(1).getText();
int flw = LA(2);
// disambiguate the special case of a table name that conflicts with a field name
// anything (even a literal) other than a very short list of reserved keywords that
// follows the next token means that it cannot be a table
// this works because the record will be a single token and the other possible
// following non-form-items are reserved keywords which can be easily checked
// and can't be used as an lvalue or field name
moreFollows = (flw != KW_EXCEPT &&
flw != KW_IN &&
flw != KW_WITH &&
flw != KW_NO_ERROR &&
flw != DOT);
isTableName = isRecord(nxt);
isFieldName = sym.isField(nxt);
// is possible for the LA(1) to be a field name in some other table in this scope; for
// this reason, we care only if LA(1) can be a table name AND LA(2) is a DOT - in this
// case, LA(1) LA(2) LA(3) may be a qualified field name, i.e. "tt .field".
if (isTableName && flw == DOT)
{
// it is possible to have a construct like DISPLAY tt .field. this allows the next
// token to be disambiguated from a record to a field reference.
int newType = resolveLvalueCoreType(1, true);
// the field name quirk was found and the tokens were merged
if (fieldNameQuirkOriginalText != null)
{
nxt = fieldNameQuirkOriginalText;
fieldNameQuirkOriginalText = null;
}
if (newType >= BEGIN_FIELDTYPES && newType <= END_FIELDTYPES)
{
isTableName = false;
isFieldName = true;
moreFollows = true;
}
}
{
_loop1487:
do {
if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_77.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
first = false;
}
else if (((_tokenSet_13.member(LA(1))) && (_tokenSet_77.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( first && isTableName && (!isFieldName || !moreFollows) && LA(2) != LPARENS )) {
record_spec(fields);
astFactory.addASTChild(currentAST, returnAST);
first = false;
}
else if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_IN && LA(1) != KW_NO_ERROR && LA(1) != KW_WITH )) {
{
if (((_tokenSet_15.member(LA(1))) && (_tokenSet_119.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(2) == KW_AS || LA(2) == KW_LIKE )) {
symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
first = false;
int numFP = 0;
// make sure these are reset every time through the loop
symbolName = null;
fld = null;
if (s_AST != null)
{
symbolName = s_AST.getText();
int type = s_AST.getType();
if (type > BEGIN_FIELDTYPES && type < END_FIELDTYPES)
{
fields.add(s_AST);
}
}
if (e_AST != null)
{
fld = findFieldNode(e_AST);
if (fld != null)
{
// if either the qualified field name quirk or the validation unqualified fixup
// were present, the original text must be saved off
if (nxt != null && !nxt.equals(fld.getText()))
{
fld.putAnnotation("original-text", nxt);
}
fields.add(fld);
}
}
s_AST = null;
e_AST = null;
{
_loop1486:
do {
if ((LA(1)==LPARENS) && (_tokenSet_75.member(LA(2))) && (_tokenSet_120.member(LA(3)))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
aggregate_phrase();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_119.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( numFP < 2 )) {
format_phrase(symbolName, fld, true, false);
astFactory.addASTChild(currentAST, returnAST);
numFP++;
}
else {
break _loop1486;
}
} while (true);
}
}
else {
break _loop1487;
}
} while (true);
}
{
switch ( LA(1)) {
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
case KW_WITH:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop1490:
do {
if ((LA(1)==KW_WITH)) {
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (frame.length() == 0)
{
String name = getFrameName(fp_AST);
if (name.length() > 0)
{
frame = name;
}
}
}
else {
break _loop1490;
}
} while (true);
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp675_AST = null;
tmp675_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp675_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
display_stmt_AST = (Aast)currentAST.root;
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
setUseDictExps(frame, fp_AST, display_stmt_AST);
display_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = display_stmt_AST;
}
/**
* Matches an <code>EMPTY TEMP-TABLE</code> language statement and the
* required following temp-table name as a {@link #record}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void empty_temp_table_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast empty_temp_table_stmt_AST = null;
Token e = null;
Aast e_AST = null;
Token tt = null;
Aast tt_AST = null;
try { // for error handling
NameNode nothing = null;
e = LT(1);
e_AST = (Aast)astFactory.create(e);
astFactory.makeASTRoot(currentAST, e_AST);
match(KW_EMPTY);
e_AST.setType(EMPTY_TEMP_TABLE);
tt = LT(1);
tt_AST = (Aast)astFactory.create(tt);
match(KW_TEMP_TAB);
hide(tt);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp676_AST = null;
tmp676_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp676_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
empty_temp_table_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = empty_temp_table_stmt_AST;
}
/**
* Matches the <code>ENABLE</code> language statement. Calls the
* {@link #all_clause}, {@link #field_clause} and {@link #frame_phrase}.
* <p>
* The <code>UNLESS-HIDDEN</code> unreserved keyword naturally conflicts with
* the possible following lvalue. This is not really ambiguous so warnings
* have been disabled.
* <p>
* This supports an undocumented feature where there is no ALL keyword or field
* list. In such a case, this is thought to be a no-operation (at runtime).
* <p>
* Used by {@link #stmt_list}.
*/
public final void enable_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast enable_stmt_AST = null;
Aast a_AST = null;
Aast fld_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
Aast tmp677_AST = null;
tmp677_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp677_AST);
match(KW_ENABLE);
{
if ((LA(1)==KW_UNL_HID) && (_tokenSet_121.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp678_AST = null;
tmp678_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp678_AST);
match(KW_UNL_HID);
}
else if ((_tokenSet_121.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_ALL:
{
all_clause();
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_WITH:
{
break;
}
default:
if ((_tokenSet_122.member(LA(1)))) {
{
int _cnt741=0;
_loop741:
do {
switch ( LA(1)) {
case KW_SKIP:
case KW_SPACE:
{
space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TEXT:
{
text_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case BOOL_TRUE:
case BOOL_FALSE:
case DEC_LITERAL:
case DATE_LITERAL:
case DATETIME_LITERAL:
case DATETIME_TZ_LITERAL:
case HEX_LITERAL:
case UNQUOTED_TEXT:
case KW_B_ENDIAN:
case KW_DLL_C_T:
case KW_EXC_LOCK:
case KW_FIND_CS:
case KW_FIND_GLO:
case KW_FIND_NO:
case KW_FIND_PO:
case KW_FIND_SEL:
case KW_FIND_WA:
case KW_FUNC_C_T:
case KW_GET_A_CT:
case KW_HOST_B_O:
case KW_L_ENDIAN:
case KW_NO_LOCK:
case KW_NO_WAIT:
case KW_PROC_C_T:
case KW_READ_AVL:
case KW_READ_E_N:
case KW_ROW_CRTD:
case KW_ROW_DELD:
case KW_ROW_MODD:
case KW_ROW_UMOD:
case KW_SAX_COMP:
case KW_SAX_PARE:
case KW_SAX_RUNN:
case KW_SAX_UNIN:
case KW_SAX_WBEG:
case KW_SAX_WCOM:
case KW_SAX_WCON:
case KW_SAX_WELM:
case KW_SAX_WERR:
case KW_SAX_WIDL:
case KW_SAX_WTAG:
case KW_SEAR_SLF:
case KW_SEAR_TRG:
case KW_SET_A_CT:
case KW_SH_LOCK:
case KW_WIN_DMIN:
case KW_WIN_MAX:
case KW_WIN_MIN:
case KW_WIN_NORM:
case STRING:
case UNKNOWN_VAL:
case NUM_LITERAL:
{
constant_form_item();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((_tokenSet_64.member(LA(1)))) {
field_clause(true);
fld_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
int type = fld_AST.getType();
if (type > BEGIN_FIELDTYPES && type < END_FIELDTYPES)
{
fields.add(fld_AST);
}
}
else {
if ( _cnt741>=1 ) { break _loop741; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt741++;
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_WITH:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
enable_stmt_AST = (Aast)currentAST.root;
String frameName = getFrameName(fp_AST);
if (!fields.isEmpty())
{
sym.addFrameFields(frameName, fields);
}
if (a_AST != null)
{
String frame = getFrameName(fp_AST);
fields = sym.getFrameFields(frame);
if (fields != null)
{
Set<String> exceptFields = new HashSet<>();
if (a_AST.downPath(KW_EXCEPT))
{
Aast ref = a_AST.getImmediateChild(CONTENT_ARRAY, null);
Iterator<Aast> iter = ref.iterator();
while (iter.hasNext())
{
ref = iter.next();
int type = ref.getType();
if (type > BEGIN_FIELDTYPES && type < END_FIELDTYPES)
{
// EXCEPT fields must not influence HELP
ref.removeAnnotation("help");
String sname = (String) ref.getAnnotation("schemaname");
String bname = (String) ref.getAnnotation("bufname");
exceptFields.add(sname + "$" + bname);
}
}
}
ASTPair allPair = new ASTPair();
astFactory.makeASTRoot(allPair, a_AST);
for (Aast fld : fields)
{
String sname = (String) fld.getAnnotation("schemaname");
String bname = (String) fld.getAnnotation("bufname");
if (exceptFields.contains(sname + "$" + bname))
{
// do not pull fields which are referenced by EXCEPT
continue;
}
Aast wid = sym.createField(sname);
wid.putAnnotation("enable_all", true);
wid.setHidden(true);
// some annotations are specific to this field definition...
wid.putAnnotation("bufname", bname);
wid.putAnnotation("name", (String) fld.getAnnotation("name"));
Aast fmt = new ProgressAst();
List<Aast> asts = attachAssignSchemaValidation(fmt, wid, sym);
if (asts != null && !asts.isEmpty())
{
a_AST.addChild(wid);
a_AST.addChild(fmt);
wid.putAnnotation("enable_all", true);
fmt.putAnnotation("enable_all", true);
fmt.setHidden(true);
fmt.setType(FORMAT_PHRASE);
fmt.setText("format phrase");
}
}
}
}
// do this last, as we need the fields for ENABLE ALL processed
setUseDictExps(frameName, fp_AST, enable_stmt_AST);
enable_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = enable_stmt_AST;
}
/**
* Matches the <code>EXPORT</code> language statement.
* <p>
* Calls:
* <p>
* <ul>
* <li> {@link #lvalue} (for stream references)
* <li> {@link #delimiter_clause}
* <li> {@link #record_spec}
* <li> {@link #space_or_skip} (undocumented but silently ignored in
* Progress)
* <li> {@link #export_field}
* </ul>
* <p>
* Used by {@link #stmt_list}.
* <p>
* In an undocumented twist, it is perfectly valid to omit any record or
* field definition in this statement, though it seems to be a NOP in such
* a case.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*/
public final void export_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast export_stmt_AST = null;
Aast ss_AST = null;
try { // for error handling
Aast tmp679_AST = null;
tmp679_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp679_AST);
match(KW_EXPORT);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_77.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_DELIMIT) && (LA(2)==STRING) && (_tokenSet_77.member(LA(3)))) {
delimiter_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_77.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_13.member(LA(1))) && (LA(2)==DOT||LA(2)==KW_EXCEPT||LA(2)==KW_NO_LOBS) && (_tokenSet_11.member(LA(3))))&&( isRecord(LT(1).getText()) )) {
record_spec(null);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
_loop758:
do {
if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
space_or_skip();
ss_AST = (Aast)returnAST;
hide(ss_AST);
}
else if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_NO_LOBS )) {
export_field();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop758;
}
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_LOBS:
{
Aast tmp680_AST = null;
tmp680_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp680_AST);
match(KW_NO_LOBS);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
export_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = export_stmt_AST;
}
/**
* Implements a <code>KW_FINALLY</code> block which is part of the structured
* error handling added in 10.2x. This uses the {@link #block} and
* {@link #end_stmt} sub-rules to match and build the tree. The tree will be
* rooted at the <code>KW_FINALLY</code> node. Variable and schema scopes are
* pushed and popped in this statement.
*/
public final void finally_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast finally_stmt_AST = null;
try { // for error handling
{
Aast tmp681_AST = null;
tmp681_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp681_AST);
match(KW_FINALLY);
block_term();
astFactory.addASTChild(currentAST, returnAST);
block();
astFactory.addASTChild(currentAST, returnAST);
end_stmt(true);
astFactory.addASTChild(currentAST, returnAST);
}
finally_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = finally_stmt_AST;
}
/**
* Matches a <code>GET</code> language statement, the required keywords and
* query name (see {@link #query_reference}). It supports all possible
* options, in any order.
* <p>
* Used by {@link #stmt_list}.
*/
public final void get_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast get_stmt_AST = null;
try { // for error handling
Aast tmp682_AST = null;
tmp682_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp682_AST);
match(KW_GET);
{
switch ( LA(1)) {
case KW_FIRST:
{
Aast tmp683_AST = null;
tmp683_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp683_AST);
match(KW_FIRST);
break;
}
case KW_LAST:
{
Aast tmp684_AST = null;
tmp684_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp684_AST);
match(KW_LAST);
break;
}
case KW_PREV:
{
Aast tmp685_AST = null;
tmp685_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp685_AST);
match(KW_PREV);
break;
}
case KW_NEXT:
{
Aast tmp686_AST = null;
tmp686_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp686_AST);
match(KW_NEXT);
break;
}
case KW_CURRENT:
{
Aast tmp687_AST = null;
tmp687_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp687_AST);
match(KW_CURRENT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
query_reference();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1219:
do {
switch ( LA(1)) {
case KW_EXC_LOCK:
case KW_NO_LOCK:
case KW_SH_LOCK:
{
{
switch ( LA(1)) {
case KW_SH_LOCK:
{
Aast tmp688_AST = null;
tmp688_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp688_AST);
match(KW_SH_LOCK);
break;
}
case KW_EXC_LOCK:
{
Aast tmp689_AST = null;
tmp689_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp689_AST);
match(KW_EXC_LOCK);
break;
}
case KW_NO_LOCK:
{
Aast tmp690_AST = null;
tmp690_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp690_AST);
match(KW_NO_LOCK);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_NO_WAIT:
{
Aast tmp691_AST = null;
tmp691_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp691_AST);
match(KW_NO_WAIT);
break;
}
default:
{
break _loop1219;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
get_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = get_stmt_AST;
}
/**
* Matches the <code>GET-KEY-VALUE</code> statement. Calls the following:
* <p>
* <ul>
* <li> {@link #section_clause}
* <li> {@link #key_clause}
* <li> {@link #value_clause}
* </ul>
* <p>
* Used by {@link #stmt_list}.
*/
public final void get_key_value_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast get_key_value_stmt_AST = null;
try { // for error handling
Aast tmp692_AST = null;
tmp692_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp692_AST);
match(KW_GET_K_V);
section_clause();
astFactory.addASTChild(currentAST, returnAST);
key_clause();
astFactory.addASTChild(currentAST, returnAST);
value_clause();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
get_key_value_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = get_key_value_stmt_AST;
}
/**
* Matches the <code>HIDE</code> language statement. Calls the
* {@link #lvalue} for stream references, {@link #widget_phrase} and
* {@link #in_window_clause} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void hide_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast hide_stmt_AST = null;
try { // for error handling
Aast tmp693_AST = null;
tmp693_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp693_AST);
match(KW_HIDE);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_123.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_MSG:
{
Aast tmp694_AST = null;
tmp694_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp694_AST);
match(KW_MSG);
break;
}
case KW_ALL:
{
Aast tmp695_AST = null;
tmp695_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp695_AST);
match(KW_ALL);
break;
}
case DOT:
case KW_IN:
case KW_NO_PAUSE:
{
break;
}
default:
if ((_tokenSet_124.member(LA(1)))) {
{
int _cnt722=0;
_loop722:
do {
if ((_tokenSet_124.member(LA(1)))) {
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt722>=1 ) { break _loop722; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt722++;
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_PAUSE:
{
Aast tmp696_AST = null;
tmp696_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp696_AST);
match(KW_NO_PAUSE);
break;
}
case DOT:
case KW_IN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
hide_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = hide_stmt_AST;
}
/**
* Matches the <code>IF THEN ELSE</code> language statement. This rule uses
* rule references {@link #then_clause} and {@link #else_clause} to properly
* build the AST.
* <p>
* This language statement has inherent ambiguity with the built-in function
* that uses the same <code>IF THEN ELSE</code> keywords (and has a nearly
* identical meaning but is only for use in expressions). Progress gives
* precedence to matching the language statement first and then the function
* form. This parser implements this rule in the {@link #statement} portion
* of the top-level {@link #single_block} rule. Since this is matched before
* expressions (which are in the {@link #assignment} rule which has lower
* precedence than <code>statement</code>) the logic works properly and all
* ambiguity is resolved.
* <p>
* Note that there is another inherent ambiguity in this construction. It is
* the classic problem with the optional <code>ELSE</code> portion of the
* rule. The standard matching of ANTLR in this case already resolves the
* detected ambiguity so there is nothing to do except disable the warnings.
* <p>
* Used by {@link #stmt_list}.
*/
public final void if_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast if_stmt_AST = null;
try { // for error handling
Aast tmp697_AST = null;
tmp697_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp697_AST);
match(KW_IF);
expr();
astFactory.addASTChild(currentAST, returnAST);
then_clause();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_ELSE) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
else_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = if_stmt_AST;
}
/**
* Matches the <code>IMPORT</code> language statement.
* <p>
* Calls:
* <p>
* <ul>
* <li> {@link #lvalue} (for stream references)
* <li> {@link #unformatted_clause}
* <li> {@link #delimiter_clause}
* <li> {@link #record_spec}
* <li> {@link #import_field} (undocumented feature: this can be zero or more instead of
* one or more as the 4GL docs indicate)
* </ul>
* <p>
* Used by {@link #stmt_list}.
*/
public final void import_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast import_stmt_AST = null;
try { // for error handling
Aast tmp698_AST = null;
tmp698_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp698_AST);
match(KW_IMPORT);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_125.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_UNFORMAT)) {
unformatted_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_126.member(LA(1)))) {
{
if ((LA(1)==KW_DELIMIT)) {
delimiter_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_127.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_13.member(LA(1))) && (_tokenSet_128.member(LA(2))) && (_tokenSet_11.member(LA(3))))&&( isRecord(LT(1).getText()) )) {
record_spec(null);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_129.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
_loop770:
do {
if ((LA(1)==CARET)) {
Aast tmp699_AST = null;
tmp699_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp699_AST);
match(CARET);
}
else if ((_tokenSet_64.member(LA(1)))) {
import_field();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop770;
}
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_LOBS:
{
Aast tmp700_AST = null;
tmp700_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp700_AST);
match(KW_NO_LOBS);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp701_AST = null;
tmp701_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp701_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
import_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = import_stmt_AST;
}
/**
* Matches the various permutations of language statements that start with
* the <code>INPUT, INPUT-OUTPUT or OUTPUT</code> keywords. It matches
* these keywords and then switches into the correct alternative based on the
* lookahead tokens.
* <p>
* This rule is called by {@link #stmt_list} and it handles the matching
* unambiguously by left factoring the common keywords for multiple language
* statements. The alternatives:
* <ul>
* <li> CLEAR (so simple that it is inlined)
* <li> CLOSE (so simple that it is inlined)
* <li> FROM {@link #io_from_to_stmt}
* <li> THROUGH/THRU {@link #io_through_stmt}
* <li> TO {@link #io_from_to_stmt}
* </ul>
* <p>
* Certain alternatives can be followed by a reference to
* {@link #io_common_options}.
*/
public final void io_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast io_stmt_AST = null;
Token inp = null;
Aast inp_AST = null;
Token ino = null;
Aast ino_AST = null;
Token otp = null;
Aast otp_AST = null;
Token cl = null;
Aast cl_AST = null;
Token clo = null;
Aast clo_AST = null;
try { // for error handling
boolean input = true;
boolean output = false;
boolean thru = false;
Token t = LT(1);
AST io_root = (Aast)astFactory.make( (new ASTArray(1)).add((Aast)astFactory.create(KW_INPUT,"i/o stmt"))); // placeholder
((Aast) io_root).setLine(t.getLine());
((Aast) io_root).setColumn(t.getColumn());
astFactory.makeASTRoot(currentAST, io_root);
{
{
switch ( LA(1)) {
case KW_INPUT:
{
inp = LT(1);
inp_AST = (Aast)astFactory.create(inp);
match(KW_INPUT);
hide(inp);
break;
}
case KW_IN_OUT:
{
ino = LT(1);
ino_AST = (Aast)astFactory.create(ino);
match(KW_IN_OUT);
hide(ino); input = false;
break;
}
case KW_OUTPUT:
{
otp = LT(1);
otp_AST = (Aast)astFactory.create(otp);
match(KW_OUTPUT);
hide(otp); input = false; output = true;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==KW_CLEAR))&&( input )) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLEAR);
hide(cl); io_root.setType(INPUT_CLEAR);
}
else if ((_tokenSet_130.member(LA(1)))) {
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_131.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_CLOSE:
{
clo = LT(1);
clo_AST = (Aast)astFactory.create(clo);
match(KW_CLOSE);
hide(clo);
if (input)
{
io_root.setType(INPUT_CLOSE);
}
else if (output)
{
io_root.setType(OUTPUT_CLOSE);
}
else
{
io_root.setType(INPUT_OUTPUT_CLOSE);
}
break;
}
case KW_FROM:
case KW_TO:
case KW_THROUGH:
{
{
if (((LA(1)==KW_FROM||LA(1)==KW_TO))&&( input || output )) {
io_from_to_stmt();
astFactory.addASTChild(currentAST, returnAST);
if (input)
{
io_root.setType(INPUT_FROM);
}
else
{
io_root.setType(OUTPUT_TO);
}
}
else if ((LA(1)==KW_THROUGH)) {
io_through_stmt();
astFactory.addASTChild(currentAST, returnAST);
thru = true;
if (input)
{
io_root.setType(INPUT_THRU);
}
else if (output)
{
io_root.setType(OUTPUT_THRU);
}
else
{
io_root.setType(INPUT_OUTPUT_THRU);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
io_common_options(output, thru);
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
io_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = io_stmt_AST;
}
/**
* Matches the <code>LOAD</code> language statement with a required following
* {@link #expr}. All options are supported and the following rules can
* be called:
* <p>
* <ul>
* <li> {@link #dir_clause}
* <li> {@link #base_key_clause}
* </ul>
* <p>
* Used by {@link #stmt_list}.
*/
public final void load_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast load_stmt_AST = null;
try { // for error handling
Aast tmp702_AST = null;
tmp702_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp702_AST);
match(KW_LOAD);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop955:
do {
switch ( LA(1)) {
case KW_DIR:
{
dir_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_APPL:
{
Aast tmp703_AST = null;
tmp703_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp703_AST);
match(KW_APPL);
break;
}
case KW_NEW:
{
Aast tmp704_AST = null;
tmp704_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp704_AST);
match(KW_NEW);
break;
}
case KW_BASE_KEY:
{
base_key_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_ERROR:
{
Aast tmp705_AST = null;
tmp705_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp705_AST);
match(KW_NO_ERROR);
break;
}
default:
{
break _loop955;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
load_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = load_stmt_AST;
}
/**
* Matches the Progress <code>MESSAGE</code> language statement and builds
* the resulting AST nodes. The string parameter is expressed as a call
* to the {@link #expr} rule.
* <p>
* The following list of rules are called to properly implement the tree
* building:
* <p>
* <ul>
* <li> {@link #simple_color_clause}
* <li> {@link #content_array}
* <li> {@link #view_as_alert_box_clause}
* <li> {@link #set_or_update_clause}
* <li> {@link #in_window_clause}
* </ul>
* <p>
* These options can be in any order. Contrary to the Progress documentation,
* it is also possible to have no expression as a message (this has been
* found in customer code and it works fine).
* <p>
* Called by {@link #stmt_list}.
*/
public final void msg_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast msg_stmt_AST = null;
try { // for error handling
Aast tmp706_AST = null;
tmp706_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp706_AST);
match(KW_MSG);
{
if ((LA(1)==KW_COLOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
simple_color_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
content_array();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1544:
do {
switch ( LA(1)) {
case KW_VIEW_AS:
{
view_as_alert_box_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SET:
case KW_UPDATE:
{
set_or_update_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1544;
}
}
} while (true);
}
{
switch ( LA(1)) {
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
msg_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = msg_stmt_AST;
}
/**
* Matches the <code>NEXT and LEAVE</code> language statements. Calls the
* {@link #label_reference} to resolve the optional label.
* <p>
* Used by {@link #stmt_list}.
*/
public final void next_or_leave_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast next_or_leave_stmt_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_NEXT:
{
Aast tmp707_AST = null;
tmp707_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp707_AST);
match(KW_NEXT);
break;
}
case KW_LEAVE:
{
Aast tmp708_AST = null;
tmp708_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp708_AST);
match(KW_LEAVE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
label_reference();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
next_or_leave_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = next_or_leave_stmt_AST;
}
/**
* Matches the <code>ON</code> language statement (which defines a trigger
* block) and implements all possible variants.
* <p>
* Used by {@link #stmt_list} and {@link #trigger_phrase}.
* <p>
* The use of the <code>event</code> rule in the leftmost token position
* is naturally ambiguous with the use of the <code>comma_event_list</code>
* since this also has an <code>event</code> in the leftmost position.
* In this case, ANTLR does not detect any ambiguity since the first
* alternative (<code>event</code>) must be followed by a match with the
* very specific <code>key_function</code> rule, so the k = 2 is enough to
* disambiguate this situation.
* <p>
* Uses:
* <p>
* <ul>
* <li> {@link #db_event}
* <li> {@link #record}
* <li> {@link #lvalue}
* <li> {@link #write_referencing_phrase}
* <li> {@link #assign_trigger_old_var_def}
* <li> {@link #event}
* <li> {@link #comma_event_list}
* <li> {@link #key_function}
* <li> {@link #comma_widget_list}
* <li> {@link #comma_events_of_widgets_clause}
* <li> {@link #persistent_trigger_procedure}
* <li> {@link #single_block} (this is the actual implementation for
* the Progress trigger block)
* </ul>
* <p>
* This is the location in which we add and remove scopes to the symbol
* dictionary for trigger blocks.
* <p>
* Bogus ambiguity warnings by ANTLR have been disabled. One of the warnings
* started when the {@link #record_funcs} rule was added to
* {@link #primary_expr}, as it creates apparent ambiguity with the
* <code>referencing_phrase</code>. The ambiguity is not real.
*/
public final void on_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast on_stmt_AST = null;
Aast evtRef_AST = null;
Token of = null;
Aast of_AST = null;
Aast recRef_AST = null;
Aast fldRef_AST = null;
try { // for error handling
boolean bypass = false;
boolean buf = false;
Aast ref = null;
Aast dbEvRef = null;
Aast recRef = null;
Aast fldRef = null;
Aast evtRef = null;
int eventType;
NameNode nothing = null;
boolean oldBufScope = setupTriggerScope();
Aast tmp709_AST = null;
tmp709_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp709_AST);
match(KW_ON);
fixupKeyboardModifiers();
{
if (((_tokenSet_132.member(LA(1))) && (LA(2)==KW_OF) && (_tokenSet_49.member(LA(3))))&&(
(sym.isTable(LT(3).getText()) && LA(1) != KW_ASSIGN) ||
(sym.isField(LT(3).getText()) && LA(1) == KW_ASSIGN)
)) {
{
db_event();
evtRef_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
of = LT(1);
of_AST = (Aast)astFactory.create(of);
match(KW_OF);
hide(of);
{
eventType = evtRef_AST.getChildAt(0).getType();
{
if (((_tokenSet_13.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( eventType == KW_CREATE || eventType == KW_DELETE || eventType == KW_FIND )) {
{
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
}
else if (((_tokenSet_13.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( eventType == KW_WRITE )) {
{
nothing=record(true, false, false);
recRef_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop880:
do {
if ((LA(1)==KW_NEW||LA(1)==KW_OLD) && (_tokenSet_15.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
write_referencing_phrase(recRef_AST);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop880;
}
} while (true);
}
{
_loop882:
do {
if ((LA(1)==KW_NEW||LA(1)==KW_OLD) && (_tokenSet_15.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
write_referencing_phrase(recRef_AST);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop882;
}
} while (true);
}
}
}
else if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( eventType == KW_ASSIGN )) {
{
lvalue();
fldRef_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
assign_trigger_old_var_def(fldRef_AST);
astFactory.addASTChild(currentAST, returnAST);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_OVERRIDE) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp710_AST = null;
tmp710_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp710_AST);
match(KW_OVERRIDE);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_108.member(LA(1))) && (_tokenSet_133.member(LA(2)))) {
event();
astFactory.addASTChild(currentAST, returnAST);
key_function();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
bypass = true;
}
else if ((_tokenSet_108.member(LA(1))) && (LA(2)==KW_OF||LA(2)==KW_ANYWHERE||LA(2)==COMMA) && (_tokenSet_134.member(LA(3)))) {
comma_event_list();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_ANYWHERE:
{
Aast tmp711_AST = null;
tmp711_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp711_AST);
match(KW_ANYWHERE);
break;
}
case KW_OF:
{
Aast tmp712_AST = null;
tmp712_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp712_AST);
match(KW_OF);
comma_widget_list();
astFactory.addASTChild(currentAST, returnAST);
{
_loop887:
do {
if ((LA(1)==KW_ANYWHERE) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp713_AST = null;
tmp713_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp713_AST);
match(KW_ANYWHERE);
}
else if ((LA(1)==KW_OR) && (_tokenSet_108.member(LA(2))) && (LA(3)==KW_OF||LA(3)==COMMA)) {
comma_events_of_widgets_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop887;
}
} while (true);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_10.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( bypass == false )) {
{
if ((LA(1)==KW_REVERT) && (LA(2)==DOT) && (_tokenSet_11.member(LA(3)))) {
Aast tmp714_AST = null;
tmp714_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp714_AST);
match(KW_REVERT);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_PERSIST) && (LA(2)==KW_RUN) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
persistent_trigger_procedure();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
single_block(true, true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_END) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
end_stmt_with_no_beginning();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
clearTriggerScope(oldBufScope);
on_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = on_stmt_AST;
}
/**
* Matches the <code>OS-APPEND, OS-COPY and OS-RENAME</code> language
* statements. Calls {@link #external_name_spec}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void os_misc_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast os_misc_stmt_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_OS_APPND:
{
Aast tmp715_AST = null;
tmp715_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp715_AST);
match(KW_OS_APPND);
break;
}
case KW_OS_COPY:
{
Aast tmp716_AST = null;
tmp716_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp716_AST);
match(KW_OS_COPY);
break;
}
case KW_OS_REN:
{
Aast tmp717_AST = null;
tmp717_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp717_AST);
match(KW_OS_REN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
os_misc_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = os_misc_stmt_AST;
}
/**
* Matches the <code>OS-CREATE-DIR</code> language statement. Calls
* {@link #external_name_spec}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void os_create_dir_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast os_create_dir_stmt_AST = null;
try { // for error handling
Aast tmp718_AST = null;
tmp718_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp718_AST);
match(KW_OS_MKDIR);
{
int _cnt1816=0;
_loop1816:
do {
// nongreedy exit test
if ( _cnt1816>=1 && (LA(1)==DOT||LA(1)==KW_NO_ERROR) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) break _loop1816;
if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt1816>=1 ) { break _loop1816; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1816++;
} while (true);
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp719_AST = null;
tmp719_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp719_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
os_create_dir_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = os_create_dir_stmt_AST;
}
/**
* Matches the <code>OS-DELETE</code> language statement. Calls {@link #value}
* and {@link #filename} rules.
* <p>
* The use of the <code>filename</code> rule in a loop is in conflict with
* the non-reserved <code>RECURSIVE</code> keyword. For this reason, the
* loop has be made non-greedy and the bogus ambiguity warnings have been
* disabled.
* <p>
* Supports an undocumented <code>NO-ERROR</code> keyword at the end.
* <p>
* Used by {@link #stmt_list}.
*/
public final void os_delete_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast os_delete_stmt_AST = null;
try { // for error handling
Aast tmp720_AST = null;
tmp720_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp720_AST);
match(KW_OS_DEL);
{
int _cnt1810=0;
_loop1810:
do {
// nongreedy exit test
if ( _cnt1810>=1 && (LA(1)==DOT||LA(1)==KW_NO_ERROR||LA(1)==KW_RECURSE) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) break _loop1810;
if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt1810>=1 ) { break _loop1810; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1810++;
} while (true);
}
{
if ((LA(1)==KW_RECURSE) && (LA(2)==DOT)) {
Aast tmp721_AST = null;
tmp721_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp721_AST);
match(KW_RECURSE);
}
else if ((LA(1)==KW_NO_ERROR) && (LA(2)==DOT)) {
Aast tmp722_AST = null;
tmp722_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp722_AST);
match(KW_NO_ERROR);
}
else if ((LA(1)==KW_RECURSE) && (LA(2)==KW_NO_ERROR)) {
{
Aast tmp723_AST = null;
tmp723_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp723_AST);
match(KW_RECURSE);
Aast tmp724_AST = null;
tmp724_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp724_AST);
match(KW_NO_ERROR);
}
}
else if ((LA(1)==KW_NO_ERROR) && (LA(2)==KW_RECURSE)) {
{
Aast tmp725_AST = null;
tmp725_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp725_AST);
match(KW_NO_ERROR);
Aast tmp726_AST = null;
tmp726_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp726_AST);
match(KW_RECURSE);
}
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
os_delete_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = os_delete_stmt_AST;
}
/**
* Matches the <code>PAGE</code> language statement. Optionally calls the
* {@link #lvalue} rule for stream references.
* <p>
* Used by {@link #stmt_list}.
*/
public final void page_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast page_stmt_AST = null;
try { // for error handling
Aast tmp727_AST = null;
tmp727_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp727_AST);
match(KW_PAGE);
{
if (((_tokenSet_64.member(LA(1))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
page_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = page_stmt_AST;
}
/**
* Matches the <code>PAUSE</code> language statement. Calls the
* {@link #in_window_clause} and {@link #simple_message_clause} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void pause_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast pause_stmt_AST = null;
try { // for error handling
Aast tmp728_AST = null;
tmp728_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp728_AST);
match(KW_PAUSE);
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_B4_HIDE && LA(1) != KW_MSG && LA(1) != KW_IN && LA(1) != KW_NO_MSG )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_135.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop728:
do {
switch ( LA(1)) {
case KW_B4_HIDE:
{
Aast tmp729_AST = null;
tmp729_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp729_AST);
match(KW_B4_HIDE);
break;
}
case KW_MSG:
case KW_NO_MSG:
{
simple_message_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop728;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
pause_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = pause_stmt_AST;
}
/**
* Matches the <code>PUBLISH</code> language statement, the required
* following character {@link #expr} and all options. Uses the
* {@link #from_handle_clause} and {@link #param_passing_list} rules.
* <p>
* Called from {@link #stmt_list}.
*/
public final void publish_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast publish_stmt_AST = null;
try { // for error handling
Aast tmp730_AST = null;
tmp730_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp730_AST);
match(KW_PUBLISH);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_FROM:
{
from_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_GLOBAL:
case LPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_GLOBAL:
{
Aast tmp731_AST = null;
tmp731_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp731_AST);
match(KW_GLOBAL);
break;
}
case DOT:
case LPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case LPARENS:
{
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
publish_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = publish_stmt_AST;
}
/**
* Matches the <code>PUT SCREEN</code> language statement. Calls the
* {@link #simple_color_clause}, {@link #ui_stuff} and {@link #expr}.
* <p>
* The <code>ui_stuff</code> rule uses unreserved keywords that naturally
* conflict with the possible following expression. This is not really
* ambiguous so warnings have been disabled.
* <p>
* Used by {@link #stmt_list}.
*/
public final void put_screen_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast put_screen_stmt_AST = null;
Token p = null;
Aast p_AST = null;
Token sc = null;
Aast sc_AST = null;
try { // for error handling
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(KW_PUT);
p_AST.setType(PUT_SCREEN);
sc = LT(1);
sc_AST = (Aast)astFactory.create(sc);
match(KW_SCREEN);
hide(sc);
{
_loop747:
do {
if ((LA(1)==KW_ATTR||LA(1)==KW_NO_ATTR) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_ATTR:
{
Aast tmp732_AST = null;
tmp732_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp732_AST);
match(KW_ATTR);
break;
}
case KW_NO_ATTR:
{
Aast tmp733_AST = null;
tmp733_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp733_AST);
match(KW_NO_ATTR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_COLOR) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
simple_color_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( LA(1) == KW_ROW || LA(1) == KW_COL || LA(1) == KW_COLUMNS )) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop747;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
put_screen_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = put_screen_stmt_AST;
}
/**
* Matches the <code>PUT CURSOR</code> language statement and builds the
* associated AST. Calls {@link #ui_stuff} for the ROW and COL options.
* <p>
* Called by {@link #stmt_list}.
*/
public final void put_cursor_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast put_cursor_stmt_AST = null;
Token p = null;
Aast p_AST = null;
Token cur = null;
Aast cur_AST = null;
try { // for error handling
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(KW_PUT);
p_AST.setType(PUT_CURSOR);
cur = LT(1);
cur_AST = (Aast)astFactory.create(cur);
match(KW_CURSOR);
hide(cur);
{
if ((LA(1)==KW_OFF)) {
Aast tmp734_AST = null;
tmp734_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp734_AST);
match(KW_OFF);
}
else if (((_tokenSet_47.member(LA(1))))&&( LA(1) == KW_ROW || LA(1) == KW_COL || LA(1) == KW_COLUMNS )) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
{
if (((_tokenSet_47.member(LA(1))))&&( LA(1) == KW_ROW || LA(1) == KW_COL || LA(1) == KW_COLUMNS )) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
put_cursor_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = put_cursor_stmt_AST;
}
public final void put_key_value_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast put_key_value_stmt_AST = null;
try { // for error handling
Aast tmp735_AST = null;
tmp735_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp735_AST);
match(KW_PUT_K_V);
{
switch ( LA(1)) {
case KW_SECTION:
{
{
section_clause();
astFactory.addASTChild(currentAST, returnAST);
key_clause();
astFactory.addASTChild(currentAST, returnAST);
value_clause();
astFactory.addASTChild(currentAST, returnAST);
}
break;
}
case KW_COLOR:
case KW_FONT:
{
color_or_font_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp736_AST = null;
tmp736_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp736_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
put_key_value_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = put_key_value_stmt_AST;
}
/**
* Matches the <code>PUT</code> language statement and builds the
* associated AST.
* <p>
* The following list of rules are called to properly implement the tree
* building:
* <p>
* <ul>
* <li> {@link #lvalue} (for stream references)
* <li> {@link #space_or_skip}
* <li> {@link #null_clause}
* <li> {@link #put_field}
* </ul>
* <p>
* Called by {@link #stmt_list}.
*/
public final void put_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast put_stmt_AST = null;
try { // for error handling
Aast tmp737_AST = null;
tmp737_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp737_AST);
match(KW_PUT);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_UNFORMAT) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp738_AST = null;
tmp738_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp738_AST);
match(KW_UNFORMAT);
}
else if ((LA(1)==KW_CONTROL) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp739_AST = null;
tmp739_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp739_AST);
match(KW_CONTROL);
}
else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1511:
do {
if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
runtime_space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NULL) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
null_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
put_field();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1511;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
put_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = put_stmt_AST;
}
/**
* Matches the <code>RAW-TRANSFER</code> language statement.
* <p>
* Calls {@link #buffer_or_field_spec}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void raw_transfer_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast raw_transfer_stmt_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
Aast tmp740_AST = null;
tmp740_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp740_AST);
match(KW_RAW_TRAN);
buffer_or_field_spec();
astFactory.addASTChild(currentAST, returnAST);
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
buffer_or_field_spec();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp741_AST = null;
tmp741_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp741_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
raw_transfer_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = raw_transfer_stmt_AST;
}
/**
* Matches the <code>READKEY</code> language statement. Optionally calls the
* {@link #lvalue} (for stream references) and {@link #pause_clause} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void readkey_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast readkey_stmt_AST = null;
try { // for error handling
Aast tmp742_AST = null;
tmp742_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp742_AST);
match(KW_READKEY);
{
if (((_tokenSet_64.member(LA(1))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_PAUSE)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_PAUSE:
{
pause_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
readkey_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = readkey_stmt_AST;
}
/**
* Matches a <code>RELEASE EXTERNAL</code> language statement, and the following required
* {@link #expr}. This also supports the use of NO-ERROR (undocumented 4GL feature).
* <p>
* Used by {@link #stmt_list}.
*/
public final void release_external_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast release_external_stmt_AST = null;
Token r = null;
Aast r_AST = null;
Token exe = null;
Aast exe_AST = null;
Token pr = null;
Aast pr_AST = null;
try { // for error handling
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.makeASTRoot(currentAST, r_AST);
match(KW_RELEASE);
r_AST.setType(RELEASE_EXTERNAL);
exe = LT(1);
exe_AST = (Aast)astFactory.create(exe);
match(KW_EXTERN);
hide(exe);
{
if ((LA(1)==KW_PROC) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PROC);
hide(pr);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp743_AST = null;
tmp743_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp743_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
release_external_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = release_external_stmt_AST;
}
/**
* Matches a <code>RELEASE OBJECT</code> language statement, and the
* following required {@link #expr}. The Progress documentation states that
* it should be a <code>COM-HANDLE</code>, but does not state whether this is
* allowed to be any expression that evaluates to a <code>COM-HANDLE</code>.
* Customer source code shows that any expression will work.
* <p>
* Used by {@link #stmt_list}.
*/
public final void release_object_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast release_object_stmt_AST = null;
Token r = null;
Aast r_AST = null;
Token ob = null;
Aast ob_AST = null;
try { // for error handling
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.makeASTRoot(currentAST, r_AST);
match(KW_RELEASE);
r_AST.setType(RELEASE_OBJECT);
ob = LT(1);
ob_AST = (Aast)astFactory.create(ob);
match(KW_OBJECT);
hide(ob);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp744_AST = null;
tmp744_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp744_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
release_object_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = release_object_stmt_AST;
}
/**
* Matches the <code>RELEASE</code> language statement. Calls the
* {@link #record}.
* <p>
* <b>At this time, the record scope in the schema is not removed when this
* rule is called. This may be something that is needed in some obscure
* case. To implement this, one would have to call
* {@link SymbolResolver#deleteSchemaScope} as well as notify the
* {@link #inner_block} rule so that it doesn't try to delete the same scope
* (this is non-trivial due to nesting). Watch for problems that might arise
* from this choice to ignore the scope deletion.</b>
* <p>
* Called by the {@link #stmt_list} rule.
*/
public final void release_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast release_stmt_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp745_AST = null;
tmp745_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp745_AST);
match(KW_RELEASE);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp746_AST = null;
tmp746_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp746_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
release_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = release_stmt_AST;
}
/**
* Matches a <code>REPOSITION</code> language statement, the required
* following query name (see {@link #query_reference}) and repositioning
* information. Uses {@link #to_recid_or_rowid_clause} and
* {@link #reposition_spec} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void reposition_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast reposition_stmt_AST = null;
try { // for error handling
Aast tmp747_AST = null;
tmp747_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp747_AST);
match(KW_REPOS);
query_reference();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TO:
{
to_recid_or_rowid_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BACKWARD:
case KW_FORWARD:
{
reposition_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp748_AST = null;
tmp748_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp748_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
reposition_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = reposition_stmt_AST;
}
/**
* Matches the Progress <code>RETURN</code> statement using a rule reference
* to {@link #return_core} and builds the resulting AST. The core logic is in
* the rule reference rather than here. The separation was made to allow
* the following <code>DOT</code> to be visible as a standalone language
* statement when called from this rule. The <code>return_core</code> rule
* can also be called as a component of another language statement rather than
* a statement that requires such a separator.
*/
public final void return_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast return_stmt_AST = null;
try { // for error handling
return_core();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
return_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = return_stmt_AST;
}
/**
* Matches the <code>KW_ROUTINEL</code> keyword with a following {@link #on_event_phrase}.
*/
public final void routine_level_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast routine_level_stmt_AST = null;
try { // for error handling
Aast tmp749_AST = null;
tmp749_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp749_AST);
match(KW_ROUTINEL);
on_event_phrase();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
routine_level_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = routine_level_stmt_AST;
}
/**
* Matches the <code>RUN STORED-PROCEDURE</code> language statement, the
* following {@link #reserved_or_symbol}, the optional {@link #assign}
* and optional {@link #param_passing_list}. The result will be rooted at a
* <code>RUN_STORED_PROCEDURE</code> node. Called from {@link #stmt_list}.
* <p>
* Warning: this is an early implementation which does not yet support the
* notion that a stored procedure is like a special kind of table type. The
* stored procedure is a schema object created in the database supported
* by a 4GL data server. That schema object is known to the 4GL and it
* is called with optional parameters (and must be closed when done). But
* to get the data out of the results, Progress creates a buffer of the same
* name as the procedure, which can be used in record phrases to read the
* data. Likewise, there are properties defined for the results which are
* treated like fields. The schema dictionary, symbol resolver and parser
* all need updates to fully support this new resource. It is likely that
* real 4GL code using these constructs will not parse properly at this time.
* Also note that there are special purpose names <code>proc-text</code> and
* <code>proc-text-buffer</code> which can be used as a field (actually it
* is a text string of the entire current record's contents) and as a buffer
* respectively. That means that definitions of these need to be created
* during this method. Following code may rely upon this to parse. Finally,
* there may be a special <code>closeallprocs</code> procedure that is
* the equivalent to calling {@link #close_stored_proc_stmt} on all currently
* open stored procedures.
*/
public final void run_stored_proc_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast run_stored_proc_stmt_AST = null;
Token r = null;
Aast r_AST = null;
Token sp = null;
Aast sp_AST = null;
try { // for error handling
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.makeASTRoot(currentAST, r_AST);
match(KW_RUN);
r_AST.setType(RUN_STORED_PROCEDURE);
sp = LT(1);
sp_AST = (Aast)astFactory.create(sp);
match(KW_STORPROC);
hide(sp);
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_64.member(LA(1)))) {
assign_proc_handle();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_NO_ERROR||LA(1)==LPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp750_AST = null;
tmp750_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp750_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
case LPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case LPARENS:
{
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
run_stored_proc_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = run_stored_proc_stmt_AST;
}
/**
* Matches the <code>RUN SUPER</code> statement with an optional following
* parameter list (see {@link #param_passing_list}). The resulting tree will be
* rooted at a <code>RUN_SUPER</code> node. Called from {@link #stmt_list}.
*/
public final void run_super_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast run_super_stmt_AST = null;
Token r = null;
Aast r_AST = null;
Token su = null;
Aast su_AST = null;
try { // for error handling
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.makeASTRoot(currentAST, r_AST);
match(KW_RUN);
r_AST.setType(RUN_SUPER);
su = LT(1);
su_AST = (Aast)astFactory.create(su);
match(KW_SUPER);
hide(su);
{
switch ( LA(1)) {
case LPARENS:
{
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp751_AST = null;
tmp751_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp751_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
run_super_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = run_super_stmt_AST;
}
/**
* Matches the Progress <code>RUN</code> language statement with all of its
* options and builds the resulting AST. This rule relies heavily upon
* lexer support in the {@link ProgressLexer#mSYMBOL} rule and upon the
* {@link #filename} rule for handling the required 2nd token (the external
* procedure name, internal procedure name or library reference). The
* {@link #value} rule is also called in the case of the user providing
* an expression to specify the name.
* <p>
* Although the Progress documentation does not say so, it is possible to
* specify the target to run as a string without using the <code>VALUE</code>
* construct. This is supported.
* <p>
* It is possible for the parser to identify something as a
* <code>FILENAME</code> when it really is a <code>INT_PROC</code> in the
* case where the internal procedure is defined after the run statement is
* encountered. This is perfectly valid in a Progress source file. This
* problem can be fixed in a subsequent processing of the parser-generated
* tree.
* <p>
* Most of the optional constructs are matched in the following rule
* references: {@link #persist_or_single_clause}, {@link #on_server_clause},
* {@link #in_procedure_clause}, {@link #trans_distinct_clause},
* {@link #set_handle} or {@link #asynch_clause}. Doing this allows the AST
* to be built cleanly.
* <p>
* Note that the manner in which the <code>PERSISTENT, ON SERVER and IN</code>
* clauses are processed allows them to appear in any order (which is how
* Progress handles it) however there is no checking to ensure that multiple
* instances of the same clause do not occur. Due to defects in ANTLR's
* code generation, the <code>ASYNCHRONOUS</code> clause,
* <code>TRANSACTION DISTINCT</code> and parameters have been moved into
* this options processing to get the code to generate properly. The result
* is the same with valid Progress code and in fact, this may even have been
* ultimately necessary. Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* As an undocumented feature, Progress allows any number of
* <code>NO-ERROR</code> keywords to be placed at the end of the statement,
* with more than 1 being equivalent to having just 1 keyword.
* <p>
* In a <code>VALUE()</code> construct there is no checking of the type
* of the result (whether it is in the procedure dictionary because it is
* an internal procedure or whether it is a filename). In addition, no
* checking of the filesystem (using <code>PROPATH</code>) is done to
* ensure that the filename is valid. Internal procedures specified via
* a name (i.e. not using <code>VALUE()</code>) are detected and the
* subsequent token type is set to <code>INT_PROC</code>.
* <p>
* Another undocumented feature is that procedure names can be reserved
* keywords, even if it is an internal procedure name. So the procedure name
* can also match a {@link #reserved_or_symbol}.
*/
public final void run_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast run_stmt_AST = null;
Aast v_AST = null;
Aast f_AST = null;
Token er = null;
Aast er_AST = null;
try { // for error handling
// DOT and EOF are hard coded in the worker routine
// TODO: UNKNOWN_TOKEN should have broken out RBRACE and PIPE
// so they can be matched individually
int[] exclude = new int[]
{
LPARENS,
RPARENS,
LBRACKET,
RBRACKET,
COMMA,
EQUALS,
NOT_EQ,
LT,
GT,
LTE,
GTE
};
CommonToken next = (CommonToken) LT(2);
String oldtxt = null;
int newlen = -1;
boolean allowAs = false;
// the run stmt can match a simple string but it can also match a string that prefixes
// other non-whitespace characters and it is the unquoted contents concatenated to the
// following text that is matched; to duplicate this we must get rid of the quotes here
// and duplicate any keyword processing that would otherwise have occurred; then we let
// the normal matching occur below; this doesn't work with VALUE(), only with the
// filename case; the reason this works is that filename uses mergeUntilWS() to handle
// the token merging
if (next.getType() == STRING)
{
oldtxt = next.getText();
// convert the Progress string to a Java string (includes escape processing and
// removal of quotes)
String txt = character.progressToJavaString(oldtxt, !unixEscapes, true);
newlen = txt.length();
// no-transform approach to simply remove quotes; it is not clear if the above
// transformations should or should not be applied
// txt = txt.substring(1, txt.length() - 1);
// save cleaned up string
next.setText(txt);
// simulate the keyword processing that would have happened if this wasn't a string
Keyword found = sym.lookupKeyword(txt);
next.setType((found != null) ? found.getTokenType() : SYMBOL);
}
Aast tmp752_AST = null;
tmp752_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp752_AST);
match(KW_RUN);
{
if ((LA(1)==LIBRARY_REF) && (_tokenSet_136.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp753_AST = null;
tmp753_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp753_AST);
match(LIBRARY_REF);
}
else if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
v_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
filename(exclude);
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
String ftxt = f_AST.getText();
int ptype = sym.lookupProcedure(ftxt);
if (ptype != -1)
{
// generally this is only triggered if the name exists
// as an internal procedure
saveAndReplaceType(f_AST, ptype);
}
else
{
// by default we assume it is an external procedure (it
// won't be in the dictionary so it can't be looked up)
f_AST.setType(FILENAME);
}
// original token (or the first token of a merged set) was STRING but was rewritten
// above; we need to calculate the actual full original text and save it for
// possible anti-parsing later
if (oldtxt != null)
{
String backend = ftxt.substring(newlen);
f_AST.putAnnotation("original-text", oldtxt + backend);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1568:
do {
if ((_tokenSet_137.member(LA(1))) && (_tokenSet_136.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
persist_or_single_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SET) && (_tokenSet_64.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
set_handle();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_ON) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
on_server_clause();
astFactory.addASTChild(currentAST, returnAST);
allowAs = true;
}
else if ((LA(1)==KW_IN) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
in_procedure_clause();
astFactory.addASTChild(currentAST, returnAST);
if (f_AST != null && f_AST.getType() == FILENAME)
f_AST.setType(INT_PROC);
}
else if ((LA(1)==KW_ASYNC) && (_tokenSet_136.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
asynch_clause();
astFactory.addASTChild(currentAST, returnAST);
allowAs = true;
}
else if ((LA(1)==LPARENS) && (_tokenSet_79.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
param_passing_list(allowAs);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1568;
}
} while (true);
}
fixupBrokenPreprocArg();
{
if (((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_NO_ERROR )) {
preproc_arguments();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_NO_ERROR) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp754_AST = null;
tmp754_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp754_AST);
match(KW_NO_ERROR);
{
_loop1572:
do {
if ((LA(1)==KW_NO_ERROR)) {
er = LT(1);
er_AST = (Aast)astFactory.create(er);
match(KW_NO_ERROR);
hide(er);
}
else {
break _loop1572;
}
} while (true);
}
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
run_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = run_stmt_AST;
}
/**
* Matches a <code>SAVE CACHE</code> language statement, and the following
* {@link #current_or_complete_clause}, {@link #value} or {@link #filename}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void save_cache_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast save_cache_stmt_AST = null;
Token s = null;
Aast s_AST = null;
Token ca = null;
Aast ca_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.makeASTRoot(currentAST, s_AST);
match(KW_SAVE);
s_AST.setType(SAVE_CACHE);
ca = LT(1);
ca_AST = (Aast)astFactory.create(ca);
match(KW_CACHE);
hide(ca);
current_or_complete_clause();
astFactory.addASTChild(currentAST, returnAST);
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp755_AST = null;
tmp755_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp755_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
save_cache_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = save_cache_stmt_AST;
}
/**
* Matches the <code>SCROLL</code> language statement. Calls the
* {@link #frame_phrase}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void scroll_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast scroll_stmt_AST = null;
try { // for error handling
Aast tmp756_AST = null;
tmp756_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp756_AST);
match(KW_SCROLL);
{
switch ( LA(1)) {
case KW_FROM_CUR:
{
Aast tmp757_AST = null;
tmp757_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp757_AST);
match(KW_FROM_CUR);
break;
}
case DOT:
case KW_DOWN:
case KW_UP:
case KW_WITH:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_UP:
{
Aast tmp758_AST = null;
tmp758_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp758_AST);
match(KW_UP);
break;
}
case KW_DOWN:
{
Aast tmp759_AST = null;
tmp759_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp759_AST);
match(KW_DOWN);
break;
}
case DOT:
case KW_WITH:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
scroll_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = scroll_stmt_AST;
}
/**
* Matches the <code>SEEK</code> language statement.
* <p>
* Calls {@link #lvalue} (for stream references) and {@link #expr} rules.
* <p>
* Used by {@link #stmt_list}.
*/
public final void seek_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast seek_stmt_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
Aast tmp760_AST = null;
tmp760_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp760_AST);
match(KW_SEEK);
{
switch ( LA(1)) {
case KW_INPUT:
{
Aast tmp761_AST = null;
tmp761_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp761_AST);
match(KW_INPUT);
break;
}
case KW_OUTPUT:
{
Aast tmp762_AST = null;
tmp762_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp762_AST);
match(KW_OUTPUT);
break;
}
default:
if (((_tokenSet_64.member(LA(1))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
{
if ((LA(1)==KW_END) && (LA(2)==DOT) && (_tokenSet_11.member(LA(3)))) {
Aast tmp763_AST = null;
tmp763_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp763_AST);
match(KW_END);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
seek_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = seek_stmt_AST;
}
/**
* Matches any operating system specific shell command (
* <code>UNIX, DOS, OS2, BTOS, CTOS and VMS</code>) and the generic shell
* command <code>OS-COMMAND</code> constructs including matching all possible
* command tokens up to a following <code>DOT</code>.
* <p>
* This rule is unusual because it accepts an arbitrary list of any possible
* or arbitrary token except the <code>DOT</code>. Any of these constructs
* can be a {@link #value} rule which allows Progress expressions to be
* evaluated and the results used as part of the command token list.
* <p>
* This approach is inherently ambiguous because the optional keywords (that
* can precede the command token list) can appear in the subsequent list.
* This ambiguity is resolved by greedily matching these keywords first.
* Ambiguity warnings have been disabled since this is not a real issue.
* <p>
* Limitations of this rule include:
* <p>
* <ul>
* <li> Unmatched double or single quotes cannot be used. Insert these
* inside a valid Progress string instead.
* <li> Whitespace that must be retained must be placed inside a valid
* Progress string.
* <li> <code>DOT</code> is used as the termination character for the
* command token list so one can only pass a '.' inside a valid
* Progress string.
* </ul>
* <p>
* Progress shared these same limitations except it can accept an unmatched
* double quotes character (which is probably just automatically ended at
* the end of the file). Progress has an additional limitation against
* using a colon followed by whitespace, which is an error. This limitation
* is not checked for by this rule.
* <p>
* Called by {@link #stmt_list}.
*/
public final void shell_command_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast shell_command_stmt_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_UNIX:
{
Aast tmp764_AST = null;
tmp764_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp764_AST);
match(KW_UNIX);
break;
}
case KW_DOS:
{
Aast tmp765_AST = null;
tmp765_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp765_AST);
match(KW_DOS);
break;
}
case KW_OS_CMD:
{
Aast tmp766_AST = null;
tmp766_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp766_AST);
match(KW_OS_CMD);
break;
}
case KW_OS2:
{
Aast tmp767_AST = null;
tmp767_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp767_AST);
match(KW_OS2);
break;
}
case KW_BTOS:
{
Aast tmp768_AST = null;
tmp768_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp768_AST);
match(KW_BTOS);
break;
}
case KW_CTOS:
{
Aast tmp769_AST = null;
tmp769_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp769_AST);
match(KW_CTOS);
break;
}
case KW_VMS:
{
Aast tmp770_AST = null;
tmp770_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp770_AST);
match(KW_VMS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_SILENT) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
Aast tmp771_AST = null;
tmp771_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp771_AST);
match(KW_SILENT);
}
else if ((LA(1)==KW_NO_WAIT) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
Aast tmp772_AST = null;
tmp772_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp772_AST);
match(KW_NO_WAIT);
}
else if (((LA(1) >= DOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_NO_CONS) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
Aast tmp773_AST = null;
tmp773_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp773_AST);
match(KW_NO_CONS);
}
else if (((LA(1) >= DOT && LA(1) <= JUNK)) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
command_token_list(false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp774_AST = null;
tmp774_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp774_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
shell_command_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = shell_command_stmt_AST;
}
/**
* Matches the <code>STATUS</code> language statement. Calls the
* {@link #in_window_clause}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void status_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast status_stmt_AST = null;
try { // for error handling
Aast tmp775_AST = null;
tmp775_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp775_AST);
match(KW_STATUS);
{
switch ( LA(1)) {
case KW_DEFAULT:
{
Aast tmp776_AST = null;
tmp776_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp776_AST);
match(KW_DEFAULT);
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_IN )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_IN) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else if ((LA(1)==DOT||LA(1)==KW_IN) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case KW_INPUT:
{
Aast tmp777_AST = null;
tmp777_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp777_AST);
match(KW_INPUT);
{
if ((LA(1)==KW_OFF) && (LA(2)==DOT||LA(2)==KW_IN) && (_tokenSet_11.member(LA(3)))) {
Aast tmp778_AST = null;
tmp778_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp778_AST);
match(KW_OFF);
}
else if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&(LA(1) != KW_IN )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_IN) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
status_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = status_stmt_AST;
}
/**
* Matches the <code>SUBSCRIBE</code> language statement, the required
* following character {@link #expr} and all options. Uses the
* {@link #proc_handle_clause}, {@link #in_procedure_clause} and
* {@link #run_proc_clause} rules.
* <p>
* Called from {@link #stmt_list}.
*/
public final void subscribe_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast subscribe_stmt_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
Aast tmp779_AST = null;
tmp779_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp779_AST);
match(KW_SUBSCRIB);
{
if ((LA(1)==KW_PROC) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
proc_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_TO) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_IN:
{
in_procedure_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ANYWHERE:
{
Aast tmp780_AST = null;
tmp780_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp780_AST);
match(KW_ANYWHERE);
break;
}
case KW_GLOBAL:
{
Aast tmp781_AST = null;
tmp781_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp781_AST);
match(KW_GLOBAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_RUN_PROC:
{
run_proc_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_NO_ERROR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp782_AST = null;
tmp782_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp782_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
subscribe_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = subscribe_stmt_AST;
}
/**
* Matches the <code>SUPER</code> statement with an optional following
* parameter list (see {@link #param_passing_list}). The resulting tree will be
* rooted at a <code>KW_SUPER</code> node. Called from {@link #stmt_list}.
* <p>
* This must be the first statement used in a {@link #constructor}.
*/
public final void super_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast super_stmt_AST = null;
try { // for error handling
Aast tmp783_AST = null;
tmp783_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp783_AST);
match(KW_SUPER);
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
super_stmt_AST = (Aast)currentAST.root;
String qname = sym.getCurrentParentName();
// this leaves notes behind regarding the called ctor
sym.annotateObjectMethod(qname, null, false, super_stmt_AST);
super_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = super_stmt_AST;
}
/**
* Matches the <code>SYSTEM-DIALOG COLOR</code> statement and all following
* options. Uses {@link #expr}, {@link #update_logical_clause} and
* {@link #in_window_handle_clause}. Called by {@link #stmt_list}.
*/
public final void system_dialog_color_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast system_dialog_color_stmt_AST = null;
Token sd = null;
Aast sd_AST = null;
Token co = null;
Aast co_AST = null;
try { // for error handling
sd = LT(1);
sd_AST = (Aast)astFactory.create(sd);
astFactory.makeASTRoot(currentAST, sd_AST);
match(KW_SYS_DLG);
sd_AST.setType(SYSTEM_DIALOG_COLOR);
co = LT(1);
co_AST = (Aast)astFactory.create(co);
match(KW_COLOR);
hide(co);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1331:
do {
switch ( LA(1)) {
case KW_UPDATE:
{
update_logical_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_window_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1331;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
system_dialog_color_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = system_dialog_color_stmt_AST;
}
/**
* Matches the <code>SYSTEM-DIALOG FONT</code> statement and all following
* options. Uses {@link #expr}, {@link #update_logical_clause},
* {@link #min_max_size_clause} and {@link #in_window_handle_clause}.
* <p>
* Called by {@link #stmt_list}.
*/
public final void system_dialog_font_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast system_dialog_font_stmt_AST = null;
Token sd = null;
Aast sd_AST = null;
Token fo = null;
Aast fo_AST = null;
try { // for error handling
sd = LT(1);
sd_AST = (Aast)astFactory.create(sd);
astFactory.makeASTRoot(currentAST, sd_AST);
match(KW_SYS_DLG);
sd_AST.setType(SYSTEM_DIALOG_FONT);
fo = LT(1);
fo_AST = (Aast)astFactory.create(fo);
match(KW_FONT);
hide(fo);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1334:
do {
switch ( LA(1)) {
case KW_ANSI_ONL:
{
Aast tmp784_AST = null;
tmp784_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp784_AST);
match(KW_ANSI_ONL);
break;
}
case KW_FIXD_ONL:
{
Aast tmp785_AST = null;
tmp785_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp785_AST);
match(KW_FIXD_ONL);
break;
}
case KW_MAX_SZ:
case KW_MIN_SZ:
{
min_max_size_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UPDATE:
{
update_logical_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_window_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1334;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
system_dialog_font_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = system_dialog_font_stmt_AST;
}
/**
* Matches the <code>SYSTEM-DIALOG GET-DIR</code> statement and all following options. Uses
* {@link #lvalue}, {@link #initial_dir_clause} and {@link #title_clause}.
* <p>
* This can also match an {@link #update_logical_clause} and/or {@link #in_window_handle_clause}
* which are both undocumented features which were found in customer applications.
* <p>
* Called by {@link #stmt_list}.
*/
public final void system_dialog_get_dir_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast system_dialog_get_dir_stmt_AST = null;
Token sd = null;
Aast sd_AST = null;
Token ge = null;
Aast ge_AST = null;
try { // for error handling
sd = LT(1);
sd_AST = (Aast)astFactory.create(sd);
astFactory.makeASTRoot(currentAST, sd_AST);
match(KW_SYS_DLG);
sd_AST.setType(SYSTEM_DIALOG_GET_DIR);
ge = LT(1);
ge_AST = (Aast)astFactory.create(ge);
match(KW_GET_DIR);
hide(ge);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1337:
do {
switch ( LA(1)) {
case KW_RET_2SD:
{
Aast tmp786_AST = null;
tmp786_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp786_AST);
match(KW_RET_2SD);
break;
}
case KW_INIT_DIR:
{
initial_dir_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TITLE:
{
title_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UPDATE:
{
update_logical_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_window_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1337;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
system_dialog_get_dir_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = system_dialog_get_dir_stmt_AST;
}
/**
* Matches the <code>SYSTEM-DIALOG GET-FILE</code> statement and all
* following options. Uses:
* <p>
* <ul>
* <li> {@link #lvalue}
* <li> {@link #update_logical_clause},
* <li> {@link #filters_clause}
* <li> {@link #title_clause}
* <li> {@link #default_extension_clause}
* <li> {@link #initial_dir_clause}
* <li> {@link #in_window_handle_clause}
* <li> {@link #at_web_browser_option}
* </ul>
* <p>
* Called by {@link #stmt_list}.
*/
public final void system_dialog_get_file_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast system_dialog_get_file_stmt_AST = null;
Token sd = null;
Aast sd_AST = null;
Token ge = null;
Aast ge_AST = null;
try { // for error handling
sd = LT(1);
sd_AST = (Aast)astFactory.create(sd);
astFactory.makeASTRoot(currentAST, sd_AST);
match(KW_SYS_DLG);
sd_AST.setType(SYSTEM_DIALOG_GET_FILE);
ge = LT(1);
ge_AST = (Aast)astFactory.create(ge);
match(KW_GET_FILE);
hide(ge);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1340:
do {
switch ( LA(1)) {
case KW_ASK_OVER:
{
Aast tmp787_AST = null;
tmp787_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp787_AST);
match(KW_ASK_OVER);
break;
}
case KW_CREAT_TF:
{
Aast tmp788_AST = null;
tmp788_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp788_AST);
match(KW_CREAT_TF);
break;
}
case KW_MUST_EXI:
{
Aast tmp789_AST = null;
tmp789_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp789_AST);
match(KW_MUST_EXI);
break;
}
case KW_RET_2SD:
{
Aast tmp790_AST = null;
tmp790_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp790_AST);
match(KW_RET_2SD);
break;
}
case KW_SAVE_AS:
{
Aast tmp791_AST = null;
tmp791_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp791_AST);
match(KW_SAVE_AS);
break;
}
case KW_USE_FIL:
{
Aast tmp792_AST = null;
tmp792_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp792_AST);
match(KW_USE_FIL);
break;
}
case KW_MULTIPLE:
{
Aast tmp793_AST = null;
tmp793_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp793_AST);
match(KW_MULTIPLE);
break;
}
case KW_DEF_EXTN:
{
default_extension_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_INIT_DIR:
{
initial_dir_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FILTERS:
{
filters_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TITLE:
{
title_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UPDATE:
{
update_logical_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_window_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_AT_W_BRW:
{
at_web_browser_option();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1340;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
system_dialog_get_file_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = system_dialog_get_file_stmt_AST;
}
/**
* Matches the <code>SYSTEM-DIALOG PRINTER-SETUP</code> statement and all
* following options. Uses {@link #expr}, {@link #update_logical_clause},
* {@link #num_copies_clause} and {@link #in_window_handle_clause}.
* <p>
* Called by {@link #stmt_list}.
*/
public final void system_dialog_printer_setup_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast system_dialog_printer_setup_stmt_AST = null;
Token sd = null;
Aast sd_AST = null;
Token ps = null;
Aast ps_AST = null;
try { // for error handling
sd = LT(1);
sd_AST = (Aast)astFactory.create(sd);
astFactory.makeASTRoot(currentAST, sd_AST);
match(KW_SYS_DLG);
sd_AST.setType(SYSTEM_DIALOG_PRINTER_SETUP);
ps = LT(1);
ps_AST = (Aast)astFactory.create(ps);
match(KW_PRT_SET);
hide(ps);
{
_loop1353:
do {
switch ( LA(1)) {
case KW_LANDSCAP:
{
Aast tmp794_AST = null;
tmp794_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp794_AST);
match(KW_LANDSCAP);
break;
}
case KW_PORTRAIT:
{
Aast tmp795_AST = null;
tmp795_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp795_AST);
match(KW_PORTRAIT);
break;
}
case KW_NUM_COPY:
{
num_copies_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UPDATE:
{
update_logical_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IN:
{
in_window_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1353;
}
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
system_dialog_printer_setup_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = system_dialog_printer_setup_stmt_AST;
}
/**
* Matches the <code>SYSTEM-HELP</code> statement and all following options.
*/
public final void system_help_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast system_help_stmt_AST = null;
try { // for error handling
Aast tmp796_AST = null;
tmp796_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp796_AST);
match(KW_SYS_HELP);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_WIN_NAME:
{
window_name_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_HELP:
case KW_QUIT:
case KW_ALT_KEY:
case KW_COMMAND:
case KW_CTX:
case KW_CTX_POP:
case KW_CONTENTS:
case KW_FINDER:
case KW_FORCE_F:
case KW_HELP_TOP:
case KW_KEY:
case KW_MULT_KEY:
case KW_PART_KEY:
case KW_POS:
case KW_SET_CONT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
help_command_clause();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
system_help_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = system_help_stmt_AST;
}
/**
* Matches the <code>THIS-OBJECT</code> statement with an optional following
* parameter list (see {@link #param_passing_list}). The resulting tree will be
* rooted at a <code>KW_THIS_OBJ</code> node. Called from {@link #stmt_list}.
* <p>
* This must be the first statement used in a {@link #constructor}.
*/
public final void this_object_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast this_object_stmt_AST = null;
try { // for error handling
Aast tmp797_AST = null;
tmp797_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp797_AST);
match(KW_THIS_OBJ);
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
this_object_stmt_AST = (Aast)currentAST.root;
String qname = sym.getCurrentClassName();
// this leaves notes behind regarding the called ctor
sym.annotateObjectMethod(qname, null, false, this_object_stmt_AST);
this_object_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = this_object_stmt_AST;
}
/**
* Support the <code>TRIGGER PROCEDURE</code> language statement. All forms
* (<code>CREATE</code>, <code>DELETE</code>, <code>FIND</code>, <code>WRITE</code> and
* <code>ASSIGN</code>, and the replication as well) are supported. Uses the
* following rules to parse:
* <p>
* <ul>
* <li> {@link #record}
* <li> {@link #write_referencing_phrase}
* <li> {@link #lvalue}
* <li> {@link #assign_trigger_old_var_def}
* </ul>
* <p>
* Called by {@link #stmt_list}.
*/
public final void trigger_procedure_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast trigger_procedure_stmt_AST = null;
Token t = null;
Aast t_AST = null;
Token p = null;
Aast p_AST = null;
Token f = null;
Aast f_AST = null;
Token of1 = null;
Aast of1_AST = null;
Token of2 = null;
Aast of2_AST = null;
Aast r_AST = null;
Token of3 = null;
Aast of3_AST = null;
Aast lv_AST = null;
Aast vd_AST = null;
try { // for error handling
NameNode nothing = null;
Aast likeRef = null;
t = LT(1);
t_AST = (Aast)astFactory.create(t);
astFactory.makeASTRoot(currentAST, t_AST);
match(KW_TRIGGER);
t_AST.setType(TRIGGER_PROCEDURE);
p = LT(1);
p_AST = (Aast)astFactory.create(p);
match(KW_PROC);
hide(p);
f = LT(1);
f_AST = (Aast)astFactory.create(f);
match(KW_FOR);
hide(f);
{
switch ( LA(1)) {
case KW_CREATE:
case KW_DELETE:
case KW_FIND:
case KW_REPL_CRE:
case KW_REPL_DEL:
{
{
switch ( LA(1)) {
case KW_CREATE:
{
Aast tmp798_AST = null;
tmp798_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp798_AST);
match(KW_CREATE);
break;
}
case KW_DELETE:
{
Aast tmp799_AST = null;
tmp799_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp799_AST);
match(KW_DELETE);
break;
}
case KW_FIND:
{
Aast tmp800_AST = null;
tmp800_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp800_AST);
match(KW_FIND);
break;
}
case KW_REPL_CRE:
{
Aast tmp801_AST = null;
tmp801_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp801_AST);
match(KW_REPL_CRE);
break;
}
case KW_REPL_DEL:
{
Aast tmp802_AST = null;
tmp802_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp802_AST);
match(KW_REPL_DEL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
of1 = LT(1);
of1_AST = (Aast)astFactory.create(of1);
match(KW_OF);
hide(of1);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_REPL_WRI:
case KW_WRITE:
{
{
switch ( LA(1)) {
case KW_WRITE:
{
Aast tmp803_AST = null;
tmp803_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp803_AST);
match(KW_WRITE);
break;
}
case KW_REPL_WRI:
{
Aast tmp804_AST = null;
tmp804_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp804_AST);
match(KW_REPL_WRI);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
of2 = LT(1);
of2_AST = (Aast)astFactory.create(of2);
match(KW_OF);
hide(of2);
nothing=record(true, false, false);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_NEW||LA(1)==KW_OLD) && (_tokenSet_15.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
write_referencing_phrase(r_AST);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_NEW||LA(1)==KW_OLD) && (_tokenSet_15.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
write_referencing_phrase(r_AST);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case KW_ASSIGN:
{
Aast tmp805_AST = null;
tmp805_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp805_AST);
match(KW_ASSIGN);
{
switch ( LA(1)) {
case KW_OF:
{
of3 = LT(1);
of3_AST = (Aast)astFactory.create(of3);
match(KW_OF);
hide(of3);
lvalue();
lv_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NEW:
{
assign_trigger_new_var_def();
vd_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
// the vd case is not exactly the "variable definition node", but it will
// suffice for our downstream needs
likeRef = (lv_AST != null) ? lv_AST : vd_AST.getImmediateChild(SYMBOL, null);
{
if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
assign_trigger_old_var_def(likeRef);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
trigger_procedure_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = trigger_procedure_stmt_AST;
}
/**
* Match the <code>TRANSACTION-MODE AUTOMATIC</code> statement. Used by
* {@link #stmt_list}.
*/
public final void transaction_mode_auto_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast transaction_mode_auto_stmt_AST = null;
Token t = null;
Aast t_AST = null;
Token au = null;
Aast au_AST = null;
try { // for error handling
t = LT(1);
t_AST = (Aast)astFactory.create(t);
astFactory.makeASTRoot(currentAST, t_AST);
match(KW_TRAN_MOD);
t_AST.setType(TRANSACTION_MODE_AUTO);
au = LT(1);
au_AST = (Aast)astFactory.create(au);
match(KW_AUTOMATC);
hide(au);
{
switch ( LA(1)) {
case KW_CHAINED:
{
Aast tmp806_AST = null;
tmp806_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp806_AST);
match(KW_CHAINED);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
transaction_mode_auto_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = transaction_mode_auto_stmt_AST;
}
/**
* Matches the <code>UNDERLINE</code> language statement. Calls the
* {@link #lvalue} (for an optional stream reference), {@link #lvalue_list}
* for the list of widgets and {@link #frame_phrase} rules.
* <p>
* As an undocumented feature of Progress, the list of widgets can be
* missing! In this case, the language statement is essentially a NOP.
* <p>
* Used by {@link #stmt_list}.
*/
public final void underline_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast underline_stmt_AST = null;
Aast fp_AST = null;
try { // for error handling
Set<Aast> fields = new HashSet<>();
Aast tmp807_AST = null;
tmp807_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp807_AST);
match(KW_UNDERLIN);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_97.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((_tokenSet_64.member(LA(1)))) {
lvalue_list(fields);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT||LA(1)==KW_WITH)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_WITH:
{
frame_phrase(false, false);
fp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
underline_stmt_AST = (Aast)currentAST.root;
String frame = getFrameName(fp_AST);
if (!fields.isEmpty())
{
sym.addFrameFields(frame, fields);
}
setUseDictExps(frame, fp_AST, underline_stmt_AST);
underline_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = underline_stmt_AST;
}
/**
* Matches the top level <code>UNDO</code> statement, but some logic is
* delegated to a shared rule {@link #undo_core} which is also used by
* {@link #on_event_phrase}. Since the {@link #throw_clause} is not
* common with the <code>on_event_phrase</code>, that sub-rule is separately
* referenced.
*/
public final void undo_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast undo_stmt_AST = null;
try { // for error handling
Aast tmp808_AST = null;
tmp808_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp808_AST);
match(KW_UNDO);
label_reference();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==COMMA) && (_tokenSet_138.member(LA(2)))) {
undo_core();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==COMMA) && (LA(2)==KW_THROW)) {
throw_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
undo_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = undo_stmt_AST;
}
/**
* Matches the <code>UNLOAD</code> language statement with a required
* following {@link #expr}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void unload_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast unload_stmt_AST = null;
try { // for error handling
Aast tmp809_AST = null;
tmp809_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp809_AST);
match(KW_UNLOAD);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp810_AST = null;
tmp810_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp810_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
unload_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = unload_stmt_AST;
}
/**
* Matches the <code>UNSUBSCRIBE</code> language statement, the required
* following character {@link #expr} and all options. Uses the
* {@link #proc_handle_clause} and {@link #in_procedure_clause}
* rules.
* <p>
* Called from {@link #stmt_list}.
*/
public final void unsubscribe_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast unsubscribe_stmt_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
Aast tmp811_AST = null;
tmp811_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp811_AST);
match(KW_UNSUBSCR);
{
if ((LA(1)==KW_PROC) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
proc_handle_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_TO) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_ALL) && (LA(2)==DOT||LA(2)==KW_GLOBAL||LA(2)==KW_IN) && (_tokenSet_11.member(LA(3)))) {
Aast tmp812_AST = null;
tmp812_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp812_AST);
match(KW_ALL);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_IN:
{
in_procedure_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_GLOBAL:
{
Aast tmp813_AST = null;
tmp813_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp813_AST);
match(KW_GLOBAL);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
unsubscribe_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = unsubscribe_stmt_AST;
}
/**
* Matches the <code>UP</code> or <code>DOWN</code> language statements.
* Optionally calls the {@link #lvalue} (for stream references) and may
* have {@link #expr} and {@link #frame_phrase} "options".
* <p>
* Options can be specified in any order.
* <p>
* Used by {@link #stmt_list}.
*/
public final void up_or_down_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast up_or_down_stmt_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_UP:
{
Aast tmp814_AST = null;
tmp814_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp814_AST);
match(KW_UP);
break;
}
case KW_DOWN:
{
Aast tmp815_AST = null;
tmp815_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp815_AST);
match(KW_DOWN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop845:
do {
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_WITH )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_WITH) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
frame_phrase(false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop845;
}
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
up_or_down_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = up_or_down_stmt_AST;
}
/**
* Matches the <code>USE</code> language statement with a required following
* {@link #expr}.
* <p>
* Used by {@link #stmt_list}.
*/
public final void use_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast use_stmt_AST = null;
try { // for error handling
Aast tmp816_AST = null;
tmp816_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp816_AST);
match(KW_USE);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp817_AST = null;
tmp817_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp817_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
use_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = use_stmt_AST;
}
/**
* Matches the <code>VALIDATE</code> language statement. Calls the
* {@link #record} rule.
* <p>
* Used by {@link #stmt_list}.
*/
public final void validate_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast validate_stmt_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp818_AST = null;
tmp818_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp818_AST);
match(KW_VALIDATE);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp819_AST = null;
tmp819_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp819_AST);
match(KW_NO_ERROR);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
validate_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = validate_stmt_AST;
}
/**
* Matches the <code>VIEW</code> language statement. Optionally calls the
* {@link #lvalue} (for stream references), {@link #widget_phrase} and
* {@link #in_window_clause} rules.
* <p>
* Progress has an undocumented feature where more than 1 widget phrase can
* be matched instead of the documented single widget phrase. This rule
* supports that undocumented mode.
* <p>
* Used by {@link #stmt_list}.
*/
public final void view_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast view_stmt_AST = null;
try { // for error handling
Aast tmp820_AST = null;
tmp820_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp820_AST);
match(KW_VIEW);
{
if (((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_STREAM || LA(1) == KW_STRM_HND )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_139.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop832:
do {
if ((_tokenSet_124.member(LA(1)))) {
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop832;
}
} while (true);
}
{
switch ( LA(1)) {
case KW_IN:
{
in_window_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
view_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = view_stmt_AST;
}
/**
* Matches the .NET version of the <code>WAIT-FOR</code> language statement.
* It calls {@link #expr} and {@link #set_lvalue}. This is ambiguous with
* the {@link #wait_for_stmt} but that ambiguity must be resolved in the
* caller using semantic predicates.
* <p>
* Used by {@link #stmt_list}.
*/
public final void wait_for_dotnet_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast wait_for_dotnet_stmt_AST = null;
Token w = null;
Aast w_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_WAIT_FOR:
{
Aast tmp821_AST = null;
tmp821_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp821_AST);
match(KW_WAIT_FOR);
break;
}
case KW_WAIT:
{
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.makeASTRoot(currentAST, w_AST);
match(KW_WAIT);
w_AST.setType(KW_WAIT_FOR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_SET:
{
set_lvalue();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
wait_for_dotnet_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = wait_for_dotnet_stmt_AST;
}
/**
* Matches the <code>WAIT-FOR</code> language statement. Calls the
* {@link #events_of_widgets_clause}, {@link #pause_clause} and
* {@link #focus_clause} rules.
* <p>
* Options can be specified in any order.
* <p>
* ANTLR reports bogus ambiguity, the code doesn't really have a problem so
* warnings have been disabled.
* <p>
* Note that there is a real ambiguous situation since the <code>FOCUS</code>
* keyword that is an option is also a valid system handle which can be
* matched as part of a widget phrase and thus it can appear in a widget
* list after the <code>OF</code> keyword. In the case where the
* <code>FOCUS</code> option immediately follows a widget list, the
* <code>FOCUS</code> keyword will be matched as a widget rather than as
* a keyword. This is because the widget lists are greedy loops and this is
* quite standard behavior. If this occurs, the tree will be different than
* one might expect. Watch for this situation.
* <p>
* Another real ambiguous situation (resolved by ordering of alternatives)
* is that the <code>PAUSE, FOCUS or EXCLUSIVE-WEB-USER</code> will be
* matched before the event list. Otherwise, such constructs can not be
* matched at all. This means that a <code>PAUSE</code> event (if there is
* such a thing) can't be matched.
* <p>
* Used by {@link #stmt_list}.
*/
public final void wait_for_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast wait_for_stmt_AST = null;
Token w = null;
Aast w_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_WAIT_FOR:
{
Aast tmp822_AST = null;
tmp822_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp822_AST);
match(KW_WAIT_FOR);
break;
}
case KW_WAIT:
{
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.makeASTRoot(currentAST, w_AST);
match(KW_WAIT);
w_AST.setType(KW_WAIT_FOR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
int _cnt903=0;
_loop903:
do {
if ((LA(1)==KW_PAUSE) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
pause_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_FOCUS) && (_tokenSet_124.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
focus_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_EXCL_WEB) && (_tokenSet_140.member(LA(2))) && (_tokenSet_141.member(LA(3)))) {
Aast tmp823_AST = null;
tmp823_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp823_AST);
match(KW_EXCL_WEB);
}
else if ((_tokenSet_108.member(LA(1))) && (_tokenSet_142.member(LA(2))) && (_tokenSet_143.member(LA(3)))) {
events_of_widgets_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt903>=1 ) { break _loop903; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt903++;
} while (true);
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
wait_for_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = wait_for_stmt_AST;
}
/**
* This is a simple placeholder to match the use of a SQL <code>SELECT</code>
* statement used directly in 4GL code in order to obtain a count of records
* from a given table.
*/
public final void embedded_sql() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast embedded_sql_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(EMBEDDED_SQL,""));
embeddedSql = true;
inUnion = false;
{
switch ( LA(1)) {
case KW_ALTER:
{
alter_table_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_CLOSE:
{
close_cursor_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DECLARE:
{
declare_cursor_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DELETE:
{
delete_from_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FETCH:
{
fetch_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_GRANT:
{
grant_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_INSERT:
{
insert_into_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OPEN:
{
open_cursor_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_REVOKE:
{
revoke_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SELECT:
{
union_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_UPDATE:
{
sql_update_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((LA(1)==KW_CREATE) && (LA(2)==KW_INDEX||LA(2)==KW_UNIQUE)) {
create_index_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_TABLE)) {
create_table_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CREATE) && (LA(2)==KW_VIEW)) {
create_view_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DROP) && (LA(2)==KW_INDEX)) {
drop_index_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DROP) && (LA(2)==KW_TABLE)) {
drop_table_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DROP) && (LA(2)==KW_VIEW)) {
drop_view_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
embeddedSql = false;
embedded_sql_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = embedded_sql_AST;
}
/**
* An empty statement (a perfectly legal Progress 4GL construct). Note that
* one can consider this a <code>NOP</code>. Strangely, an optional
* <code>NO-LOCK</code>, <code>SHARE-LOCK</code> or
* <code>EXCLUSIVE-LOCK</code> keyword can be present. If a locking keyword
* is present, then <code>NO-ERROR</code> can also be optionally specified
* (after the locking keyword).
*/
public final void empty_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast empty_stmt_AST = null;
Token nl = null;
Aast nl_AST = null;
Token sl = null;
Aast sl_AST = null;
Token el = null;
Aast el_AST = null;
Token ne = null;
Aast ne_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_EXC_LOCK:
case KW_NO_LOCK:
case KW_SH_LOCK:
{
{
switch ( LA(1)) {
case KW_NO_LOCK:
{
nl = LT(1);
nl_AST = (Aast)astFactory.create(nl);
match(KW_NO_LOCK);
hide(nl);
break;
}
case KW_SH_LOCK:
{
sl = LT(1);
sl_AST = (Aast)astFactory.create(sl);
match(KW_SH_LOCK);
hide(sl);
break;
}
case KW_EXC_LOCK:
{
el = LT(1);
el_AST = (Aast)astFactory.create(el);
match(KW_EXC_LOCK);
hide(el);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
ne = LT(1);
ne_AST = (Aast)astFactory.create(ne);
match(KW_NO_ERROR);
hide(ne);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
empty_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = empty_stmt_AST;
}
/**
* Matches the FWD-extension language statement <code>OPEN-URL</code> and a mandatory
* following character expression.
*/
public final void p2j_open_url_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast p2j_open_url_stmt_AST = null;
try { // for error handling
Aast tmp824_AST = null;
tmp824_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp824_AST);
match(KW_OPEN_URL);
expr();
astFactory.addASTChild(currentAST, returnAST);
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
p2j_open_url_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = p2j_open_url_stmt_AST;
}
/**
* Matches the FWD-extension language statement <code>OPEN-MIME-RESOURCE</code> and a mandatory
* pair of resource mime type character and its url character expression. If an optional
* <code>DELETE-SOURCE</code> is present, then it forces to delete the original input file
* when the transfer is complete.
*/
public final void open_mime_resource_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast open_mime_resource_stmt_AST = null;
try { // for error handling
Aast tmp825_AST = null;
tmp825_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp825_AST);
match(KW_OPENMIME);
expr();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_EMBED:
{
Aast tmp826_AST = null;
tmp826_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp826_AST);
match(KW_NO_EMBED);
break;
}
case DOT:
case KW_DEL_S_C:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_DEL_S_C:
{
Aast tmp827_AST = null;
tmp827_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp827_AST);
match(KW_DEL_S_C);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
open_mime_resource_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = open_mime_resource_stmt_AST;
}
/**
* Matches the <code>WEB-FILE-UPLOAD</code> statement and all
* following options. Uses:
* <p>
* <ul>
* <li> {@link #single_widget_list},
* <li> {@link #comma_event_list}
* <li> {@link #at_web_browser_upload}
* <li> {@link #title_clause}
* <li> {@link #filters_clause}
* </ul>
* <p>
* Called by {@link #stmt_list}.
*/
public final void web_file_upload_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast web_file_upload_stmt_AST = null;
Token wu = null;
Aast wu_AST = null;
try { // for error handling
wu = LT(1);
wu_AST = (Aast)astFactory.create(wu);
astFactory.makeASTRoot(currentAST, wu_AST);
match(KW_WEB_FUP);
{
switch ( LA(1)) {
case KW_REGISTER:
{
{
match(KW_REGISTER);
wu_AST.putAnnotation("register", true);
single_widget_list();
astFactory.addASTChild(currentAST, returnAST);
comma_event_list();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1349:
do {
switch ( LA(1)) {
case KW_MULTIPLE:
{
Aast tmp829_AST = null;
tmp829_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp829_AST);
match(KW_MULTIPLE);
break;
}
case KW_UPLOAD:
{
at_web_browser_upload();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_TITLE:
{
title_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FILTERS:
{
filters_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop1349;
}
}
} while (true);
}
}
break;
}
case KW_DE_REGIS:
{
{
match(KW_DE_REGIS);
single_widget_list();
astFactory.addASTChild(currentAST, returnAST);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
stmt_term();
astFactory.addASTChild(currentAST, returnAST);
web_file_upload_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = web_file_upload_stmt_AST;
}
/**
* Implements the preselect phrase which is used to modify certain block
* types to specify how to prequery the database to create a result set
* that would not otherwise be available. The tree is rooted at the
* <code>PRESELECT</code> keyword and use rule references to implement
* a more natural tree structure. See {@link #each_first_last_spec},
* {@link #by_clause} and {@link #collate_clause} for more details.
* <p>
* Used by {@link #do_repeat_stmt} and similar code is inlined in the
* {@link #for_stmt}.
*/
public final void preselect_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast preselect_phrase_AST = null;
try { // for error handling
Aast tmp831_AST = null;
tmp831_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp831_AST);
match(KW_PRESEL);
each_first_last_spec(true, true);
astFactory.addASTChild(currentAST, returnAST);
preselect_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = preselect_phrase_AST;
}
/**
* Matches common options that a <code>FOR, DO or REPEAT</code> Progress 4GL
* language statement can implement.
* <p>
* Note that the block control options are defined such that they can be
* accepted in any order. In addition, there is no check to ensure that
* only one of each option is used, although this will not cause a problem
* for correct Progress 4GL source.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Called by {@link #for_stmt} and {@link #do_repeat_stmt}.
* <p>
* Uses:
* {@link #query_tuning_phrase}
* {@link #while_clause}
* {@link #on_event_phrase}
* {@link #loop_incr}
* {@link #collate_clause}
* {@link #sort_order_clause}
* {@link #frame_phrase}
* {@link #down_clause_or_loop_incr}
*
* @return A loop increment sub-tree that was matched in a frame phrase
* due to ambiguity and which needs to be moved to the caller's
* tree. If <code>null</code> there is nothing to do.
*/
public final Aast common_block_options() throws RecognitionException, TokenStreamException {
Aast loop;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast common_block_options_AST = null;
Token g = null;
Aast g_AST = null;
Aast f_AST = null;
loop = null;
try { // for error handling
{
if ((LA(1)==KW_WHILE) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
while_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TRANS) && (_tokenSet_144.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp832_AST = null;
tmp832_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp832_AST);
match(KW_TRANS);
}
else if ((LA(1)==KW_STOP_AFT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp833_AST = null;
tmp833_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp833_AST);
match(KW_STOP_AFT);
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_ON) && (_tokenSet_145.member(LA(2))) && (_tokenSet_101.member(LA(3)))) {
on_event_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_QRY_TUNE) && (LA(2)==LPARENS) && (_tokenSet_146.member(LA(3)))) {
query_tuning_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_BREAK) && (_tokenSet_144.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp834_AST = null;
tmp834_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp834_AST);
match(KW_BREAK);
sym.endIndexFieldSearch();
}
else if ((LA(1)==KW_GROUP) && (_tokenSet_144.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
g = LT(1);
g_AST = (Aast)astFactory.create(g);
astFactory.addASTChild(currentAST, g_AST);
match(KW_GROUP);
saveAndReplaceType(g_AST, KW_BREAK);
}
else if ((LA(1)==KW_BY||LA(1)==KW_COLLATE) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
{
switch ( LA(1)) {
case KW_COLLATE:
{
collate_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BY:
{
sort_order_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( isValidLeftmostReserved(LT(1), LT(2)) )) {
loop_incr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_WITH) && (_tokenSet_147.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
frame_phrase(true, false);
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
loop = f_AST.getImmediateChild(KW_TO, null);
if (loop != null)
{
// fixups haven't been done yet so we force the parent which
// is a prerequiisite for remove()
loop.setParent(f_AST);
loop.remove();
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
common_block_options_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = common_block_options_AST;
return loop;
}
/**
* Matches the construction used in the {@link #preselect_phrase},
* {@link #for_or_preselect_clause} and in the {@link #for_stmt} for
* specifying one or more {@link #record_phrase} specifications and
* optionally prefixing the phrase with the <code>EACH, FIRST or LAST</code>
* keywords.
*
* @param force
* <code>true</code> to force promotion even if the record was
* already previously promoted.
* @param noProp
* <code>true</code> to force any promoted nodes to have their
* no propagate flag set. This disables propagation of these
* nodes across the current scope boundary.
*/
public final void each_first_last_spec(
boolean force, boolean noProp
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast each_first_last_spec_AST = null;
Aast r_AST = null;
try { // for error handling
sym.startIndexFieldSearch();
{
{
switch ( LA(1)) {
case KW_EACH:
{
Aast tmp835_AST = null;
tmp835_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp835_AST);
match(KW_EACH);
break;
}
case KW_FIRST:
{
Aast tmp836_AST = null;
tmp836_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp836_AST);
match(KW_FIRST);
break;
}
case KW_LAST:
{
Aast tmp837_AST = null;
tmp837_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp837_AST);
match(KW_LAST);
break;
}
default:
if ((_tokenSet_13.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
record_phrase(force, noProp);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
sym.setIndexFieldSearchTable(r_AST);
{
_loop1165:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_EACH:
{
Aast tmp838_AST = null;
tmp838_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp838_AST);
match(KW_EACH);
break;
}
case KW_FIRST:
{
Aast tmp839_AST = null;
tmp839_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp839_AST);
match(KW_FIRST);
break;
}
case KW_LAST:
{
Aast tmp840_AST = null;
tmp840_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp840_AST);
match(KW_LAST);
break;
}
default:
if ((_tokenSet_13.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
record_phrase(force, noProp);
astFactory.addASTChild(currentAST, returnAST);
// if more than one record phrase, can't use
sym.endIndexFieldSearch();
}
else {
break _loop1165;
}
} while (true);
}
}
each_first_last_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = each_first_last_spec_AST;
}
/**
* Matches the loop termination expression defined by the <code>WHILE</code>
* keyword. The keyword is always followed by an expression.
* <p>
* Used by {@link #do_repeat_stmt} and {@link #for_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void while_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast while_clause_AST = null;
try { // for error handling
Aast tmp841_AST = null;
tmp841_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp841_AST);
match(KW_WHILE);
expr();
astFactory.addASTChild(currentAST, returnAST);
while_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = while_clause_AST;
}
/**
* Matches the <code>ON { ENDKEY | ERROR | QUIT | STOP } UNDO</code>
* construction used to modify block processing. This is a more efficient
* coding than normally found in Progress 4GL documentation. More
* specifically, normally these 4 possible constructions are defined
* separately, but in fact their structure is identical.
* <p>
* The core logic is shared with the <code>UNDO</code> statement and
* implemented in a shared rule {@link #undo_core}. The exception to this
* is the <code>KW_THROW</code> option which is different (and thus is matched
* separately.
* <p>
* Used from {@link #do_repeat_stmt} and {@link #for_stmt}.
*/
public final void on_event_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast on_event_phrase_AST = null;
try { // for error handling
boolean isQuit = false;
boolean isErr = false;
Aast tmp842_AST = null;
tmp842_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp842_AST);
match(KW_ON);
{
switch ( LA(1)) {
case KW_ENDKEY:
{
Aast tmp843_AST = null;
tmp843_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp843_AST);
match(KW_ENDKEY);
break;
}
case KW_ERROR:
{
Aast tmp844_AST = null;
tmp844_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp844_AST);
match(KW_ERROR);
isErr = true;
break;
}
case KW_QUIT:
{
Aast tmp845_AST = null;
tmp845_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp845_AST);
match(KW_QUIT);
isQuit = true;
break;
}
case KW_STOP:
{
Aast tmp846_AST = null;
tmp846_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp846_AST);
match(KW_STOP);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==KW_UNDO) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( !isQuit || LA(1) == KW_UNDO )) {
undo_basic();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_101.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==COMMA) && (_tokenSet_138.member(LA(2)))) {
undo_core();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==COMMA) && (LA(2)==KW_THROW)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp847_AST = null;
tmp847_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp847_AST);
match(KW_THROW);
}
else if ((_tokenSet_144.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
on_event_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = on_event_phrase_AST;
}
/**
* Implements the query tuning phrase including all possible options. In
* some cases rule references are used to ensure that the tree is built
* in the most useful manner.
* <p>
* Used by {@link #do_repeat_stmt} and {@link #for_stmt}.
*/
public final void query_tuning_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast query_tuning_phrase_AST = null;
try { // for error handling
Aast tmp848_AST = null;
tmp848_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp848_AST);
match(KW_QRY_TUNE);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1181:
do {
switch ( LA(1)) {
case KW_ARR_MSG:
case KW_NO_ARMSG:
{
{
switch ( LA(1)) {
case KW_ARR_MSG:
{
Aast tmp849_AST = null;
tmp849_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp849_AST);
match(KW_ARR_MSG);
break;
}
case KW_NO_ARMSG:
{
Aast tmp850_AST = null;
tmp850_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp850_AST);
match(KW_NO_ARMSG);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_BIND_WH:
case KW_NO_BIND:
{
{
switch ( LA(1)) {
case KW_BIND_WH:
{
Aast tmp851_AST = null;
tmp851_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp851_AST);
match(KW_BIND_WH);
break;
}
case KW_NO_BIND:
{
Aast tmp852_AST = null;
tmp852_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp852_AST);
match(KW_NO_BIND);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_CACHE_SZ:
{
query_tuning_cache_size();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DEBUG:
case KW_NO_DEBUG:
{
{
switch ( LA(1)) {
case KW_DEBUG:
{
query_tuning_debug();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_DEBUG:
{
Aast tmp853_AST = null;
tmp853_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp853_AST);
match(KW_NO_DEBUG);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_HINT:
{
query_tuning_hint();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_IDX_HINT:
case KW_NO_IDX_H:
{
{
switch ( LA(1)) {
case KW_IDX_HINT:
{
Aast tmp854_AST = null;
tmp854_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp854_AST);
match(KW_IDX_HINT);
break;
}
case KW_NO_IDX_H:
{
Aast tmp855_AST = null;
tmp855_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp855_AST);
match(KW_NO_IDX_H);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_JOIN_BY:
case KW_NO_JOIN:
{
{
switch ( LA(1)) {
case KW_JOIN_BY:
{
Aast tmp856_AST = null;
tmp856_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp856_AST);
match(KW_JOIN_BY);
break;
}
case KW_NO_JOIN:
{
Aast tmp857_AST = null;
tmp857_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp857_AST);
match(KW_NO_JOIN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_LOOKAHD:
case KW_NO_LOOKA:
{
{
switch ( LA(1)) {
case KW_LOOKAHD:
{
Aast tmp858_AST = null;
tmp858_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp858_AST);
match(KW_LOOKAHD);
break;
}
case KW_NO_LOOKA:
{
Aast tmp859_AST = null;
tmp859_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp859_AST);
match(KW_NO_LOOKA);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_ORD_JOIN:
{
Aast tmp860_AST = null;
tmp860_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp860_AST);
match(KW_ORD_JOIN);
break;
}
case KW_REV_FROM:
{
Aast tmp861_AST = null;
tmp861_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp861_AST);
match(KW_REV_FROM);
break;
}
case KW_NO_SEP_C:
case KW_SEP_CONN:
{
{
switch ( LA(1)) {
case KW_SEP_CONN:
{
Aast tmp862_AST = null;
tmp862_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp862_AST);
match(KW_SEP_CONN);
break;
}
case KW_NO_SEP_C:
{
Aast tmp863_AST = null;
tmp863_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp863_AST);
match(KW_NO_SEP_C);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
default:
{
break _loop1181;
}
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
query_tuning_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = query_tuning_phrase_AST;
}
/**
* Matches the <code>COLLATE</code> keyword and the required following
* 2 or 3 character expressions. The tree is rooted on the
* <code>COLLATE</code> keyword and all parenthesis and commas are
* dropped from the tree. The resulting tree will have 2 or 3 children,
* each an expression.
* <p>
* Used by {@link #preselect_phrase} and the subtree is rooted by the
* keyword (which is the reason for using a separate rule for something so
* simple).
*/
public final void collate_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast collate_clause_AST = null;
try { // for error handling
Aast tmp864_AST = null;
tmp864_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp864_AST);
match(KW_COLLATE);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_DESCEND) && (_tokenSet_144.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp865_AST = null;
tmp865_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp865_AST);
match(KW_DESCEND);
}
else if ((_tokenSet_144.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
collate_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = collate_clause_AST;
}
/**
* Matches the <code>BY</code> keyword, the required following expression
* and the optional <code>DESCENDING</code> keyword.
* <p>
* Used by {@link #open_query_stmt} and {@link #common_block_options} rules.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void sort_order_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sort_order_clause_AST = null;
Token b = null;
Aast b_AST = null;
Aast e_AST = null;
try { // for error handling
preferFields = true;
boolean drop = sym.isFoundUniqueIndex();
if (drop)
{
// if we found an unique index, then every following BY clause needs to be dropped;
// to do this, we allow any symbol matching (including uninterpretable/garbage 4GL
// code) which will be dropped later on by unreachable code phase
allowSymbolMatch = true;
}
sym.useIndexFieldSearch(true);
b = LT(1);
b_AST = (Aast)astFactory.create(b);
astFactory.makeASTRoot(currentAST, b_AST);
match(KW_BY);
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_DESCEND) && (_tokenSet_144.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp866_AST = null;
tmp866_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp866_AST);
match(KW_DESCEND);
}
else if ((_tokenSet_144.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
preferFields = false;
sym.collectSortField(e_AST);
sym.useIndexFieldSearch(false);
if (drop)
{
allowSymbolMatch = false;
b_AST.putAnnotation("drop", true);
}
sort_order_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = sort_order_clause_AST;
}
/**
* Matches the loop increment definition defined by the <code>TO</code>
* keyword and optionally the <code>BY</code> keyword. Common rule references
* were used to reuse working, tested code, however the resulting tree may
* not be intuitive since the leftmost child of the root <code>TO</code>
* keyword will be an {@link #assign} (which is rooted by an
* <code>ASSIGN</code> token that has an lvalue and expression as children.
* The next child of the <code>TO</code> is the loop terminating expression
* followed by the optional {@link #by_clause}.
* <p>
* Used by {@link #do_repeat_stmt} and {@link #for_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*/
public final void loop_incr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast loop_incr_AST = null;
try { // for error handling
assign();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp867_AST = null;
tmp867_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp867_AST);
match(KW_TO);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_BY) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
by_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_144.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
loop_incr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = loop_incr_AST;
}
/**
* Implements the semantics of the assignment sub-expression in a Progress
* <code>ASSIGN</code> language statement.
* <p>
* The syntax is differentiated from a top level {@link #assignment}
* statement by:
* <ul>
* <li> the requirement that there be an lvalue in the leftmost position
* <li> an expression cannot stand alone (without a prefixed lvalue and
* assignment operator)
* <li> no terminating <code>DOT</code>
* </ul>
* <p>
* This is referenced from {@link #assign_stmt}, {@link #loop_incr} and
* {@link #sub_assign_clause} rules. It is used to implement the core
* assignment logic.
* <p>
* A special mode exists that allows for an <code>lvalue</code> prefixed
* with a frame or browse reference.
* <p>
* Creates both operands as children of the artificially created
* <code>ASSIGN</code> token type (which the <code>EQUALS</code> token is
* replaced by).
*/
public final void assign() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assign_AST = null;
Aast l_AST = null;
Token eqEquals = null;
Aast eqEquals_AST = null;
Token eqMult = null;
Aast eqMult_AST = null;
Token eqPlus = null;
Aast eqPlus_AST = null;
Token eqMinus = null;
Aast eqMinus_AST = null;
Token eqDiv = null;
Aast eqDiv_AST = null;
try { // for error handling
{
if ((LA(1)==KW_INPUT) && (_tokenSet_85.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp868_AST = null;
tmp868_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp868_AST);
match(KW_INPUT);
}
else if ((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
chained_object_members();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case EQUALS:
{
eqEquals = LT(1);
eqEquals_AST = (Aast)astFactory.create(eqEquals);
astFactory.makeASTRoot(currentAST, eqEquals_AST);
match(EQUALS);
eqEquals_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case MULT_ASSIGN:
{
eqMult = LT(1);
eqMult_AST = (Aast)astFactory.create(eqMult);
astFactory.makeASTRoot(currentAST, eqMult_AST);
match(MULT_ASSIGN);
eqMult_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case PLUS_ASSIGN:
{
eqPlus = LT(1);
eqPlus_AST = (Aast)astFactory.create(eqPlus);
astFactory.makeASTRoot(currentAST, eqPlus_AST);
match(PLUS_ASSIGN);
eqPlus_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case MINUS_ASSIGN:
{
eqMinus = LT(1);
eqMinus_AST = (Aast)astFactory.create(eqMinus);
astFactory.makeASTRoot(currentAST, eqMinus_AST);
match(MINUS_ASSIGN);
eqMinus_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DIV_ASSIGN:
{
eqDiv = LT(1);
eqDiv_AST = (Aast)astFactory.create(eqDiv);
astFactory.makeASTRoot(currentAST, eqDiv_AST);
match(DIV_ASSIGN);
eqDiv_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((_tokenSet_144.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
restoreAssignStyleStmt(l_AST);
if (eqEquals_AST != null)
{
restoreEqualsOperator(l_AST, eqEquals_AST);
}
else if (eqMult_AST != null)
{
restoreEqualsOperator(l_AST, eqMult_AST);
}
else if (eqPlus_AST != null)
{
restoreEqualsOperator(l_AST, eqPlus_AST);
}
else if (eqMinus_AST != null)
{
restoreEqualsOperator(l_AST, eqMinus_AST);
}
else if (eqDiv_AST != null)
{
restoreEqualsOperator(l_AST, eqDiv_AST);
}
assign_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = assign_AST;
}
/**
* Matches the <code>THEN</code> block of an <code>IF THEN ELSE</code>
* language statement. This rule makes a single, recursive call to the
* core rule {@link #single_block}. This allows a single statement, inner
* block (<code>DO, REPEAT or FOR</code>) or assignment to be included
* after the <code>THEN</code>. Note that no checking is done on whether
* a function, trigger or procedure definition is used instead of the above
* constructions. While this seems wrong, it is exactly how Progress handles
* this situation (without complaining)!
* <p>
* It is possible to have an empty then block if the next statement is
* <code>END</code> or if the end of file is reached. Progress tolerates
* this syntax silently.
* <p>
* Used by {@link #if_stmt} and {@link #when_clause}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void then_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast then_clause_AST = null;
try { // for error handling
checkAndFixLabelWithReservedKeywordPrefix(2);
Aast tmp869_AST = null;
tmp869_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp869_AST);
match(KW_THEN);
{
if (((_tokenSet_10.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != EOF && LA(1) != KW_END )) {
single_block(true, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
then_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = then_clause_AST;
}
/**
* Matches the <code>ELSE</code> block of an <code>IF THEN ELSE</code>
* language statement. This rule makes a single, recursive call to the
* core rule {@link #single_block}. This allows a single statement, inner
* block (<code>DO, REPEAT or FOR</code>) or assignment to be included
* after the <code>ELSE</code>. Note that no checking is done on whether
* a function, trigger or procedure definition is used instead of the above
* constructions. While this seems wrong, it is exactly how Progress handles
* this situation (without complaining)!
* <p>
* It is legal for this block (which follows the <code>ELSE</code> keyword)
* to be missing. For this reason, the call to <code>single_block</code>
* was made optional. As usual, bogus ANTLR ambiguity warnings are disabled.
* <p>
* Used by {@link #if_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void else_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast else_clause_AST = null;
try { // for error handling
checkAndFixLabelWithReservedKeywordPrefix(2);
Aast tmp870_AST = null;
tmp870_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp870_AST);
match(KW_ELSE);
{
if (((_tokenSet_10.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_END && LA(1) != EOF )) {
single_block(true, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
else_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = else_clause_AST;
}
/**
* Matches the <code>WHEN</code> block of a <code>CASE</code>
* language statement. After matching the list of possible expressions using
* the {@link #simple_when_clause} rule reference, this rule makes a single
* call to the {@link #then_clause}.
* <p>
* Used by {@link #case_stmt}.
* <p>
* Note that there is an ambiguity caused between the <code>OR</code> keyword
* implemented in {@link #expr} and by the use of the <code>OR</code>
* keyword in a <code>WHEN</code> clause (additional WHEN conditions can
* be added to the same statement using an <code>OR WHEN condition</code>
* syntax). Since the following condition is an expression, one must detect
* the use of the following <code>WHEN</code> as the next token after the
* <code>OR</code> to disambiguate. The <code>expr</code> rule which
* implements the logical <code>OR</code> processing thus uses a semantic
* predicate to terminate expression processing (and not match on the
* <code>OR</code> in the case where lookahead 2 is the reserved keyword
* <code>WHEN</code>.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void when_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast when_clause_AST = null;
Token or = null;
Aast or_AST = null;
try { // for error handling
simple_when_clause();
astFactory.addASTChild(currentAST, returnAST);
{
_loop500:
do {
if ((LA(1)==KW_OR)) {
or = LT(1);
or_AST = (Aast)astFactory.create(or);
match(KW_OR);
hide(or);
simple_when_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop500;
}
} while (true);
}
then_clause();
astFactory.addASTChild(currentAST, returnAST);
when_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = when_clause_AST;
}
/**
* Matches the <code>OTHERWISE</code> block of a <code>CASE</code>
* language statement. This rule makes a single, recursive call to the
* core rule {@link #single_block}. This allows a single statement, inner
* block (<code>DO, REPEAT or FOR</code>) or assignment to be included
* after the <code>THEN</code>. Note that no checking is done on whether
* a function, trigger or procedure definition is used instead of the above
* constructions. While this seems wrong, it is exactly how Progress handles
* this situation (without complaining)!
* <p>
* Used by {@link #case_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void otherwise() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast otherwise_AST = null;
try { // for error handling
checkAndFixLabelWithReservedKeywordPrefix(2);
Aast tmp871_AST = null;
tmp871_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp871_AST);
match(KW_OTHER);
single_block(true, false);
astFactory.addASTChild(currentAST, returnAST);
otherwise_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = otherwise_AST;
}
/**
* Implements the record phrase used in various block definitions. In its
* most basic form, a table ({@link #record}) and optional include or exclude
* list of fields is provided ({@link #field_list}). Uses the
* {@link #literal} rule to match the optional constant that follows the
* field list. The {@link #join_clause}, {@link #of_clause},
* {@link #where_clause}, {@link #using_clause} and {@link #use_index_clause}
* rules are all implemented separately to generate the proper tree
* structure. Note that these last options can be specified in any order and
* multiple times.
* <p>
* The join clause is only here for use by {@link #each_first_last_spec} and
* not by {@link #find_stmt}. Likewise the <code>NO-WAIT and NO-ERROR</code>
* keywords are only here for <code>FIND</code>. Otherwise this single
* rule properly handles both cases.
* <p>
* Note that the use of unreserved keywords for <code>OUTER-JOIN</code> and
* <code>LEFT</code> can cause ambiguity when k == 2 between the join_clause
* and the of_clause (which includes the {@link #symbol} rule). In practice,
* this is not really a problem because join_clause is a more specific rule.
* For this reason, ambiguity warnings have been disabled.
*
* @param force
* <code>true</code> to force promotion even if the record was
* already previously promoted.
* @param noProp
* <code>true</code> to force any promoted nodes to have their
* no propagate flag set. This disables propagation of these
* nodes across the current scope boundary.
*/
public final void record_phrase(
boolean force, boolean noProp
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast record_phrase_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(RECORD_PHRASE,"record phrase"));
boolean old = sym.markPreferred(true);
NameNode oldRecord = currentRecord;
int whereClauses = 0;
currentRecord=record(true, force, noProp);
astFactory.addASTChild(currentAST, returnAST);
sym.markPreferred(old);
{
if ((LA(1)==KW_EXCEPT||LA(1)==KW_FIELD) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
field_list();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_148.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_65.member(LA(1))) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
LA(1) != KW_SH_LOCK && LA(1) != KW_EXC_LOCK &&
LA(1) != KW_NO_LOCK && LA(1) != KW_NO_WAIT
)) {
literal();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_148.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1194:
do {
if ((LA(1)==KW_LEFT||LA(1)==KW_OUT_JOIN) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
join_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_OF) && (_tokenSet_13.member(LA(2))) && (_tokenSet_148.member(LA(3)))) {
of_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_WHERE) && (_tokenSet_149.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( whereClauses == 0 )) {
where_clause(false);
astFactory.addASTChild(currentAST, returnAST);
whereClauses++;
}
else if ((LA(1)==KW_USE_IDX) && (_tokenSet_53.member(LA(2))) && (_tokenSet_148.member(LA(3)))) {
use_index_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_USING) && (_tokenSet_150.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
using_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_EXC_LOCK||LA(1)==KW_NO_LOCK||LA(1)==KW_SH_LOCK) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SH_LOCK:
{
Aast tmp872_AST = null;
tmp872_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp872_AST);
match(KW_SH_LOCK);
break;
}
case KW_EXC_LOCK:
{
Aast tmp873_AST = null;
tmp873_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp873_AST);
match(KW_EXC_LOCK);
break;
}
case KW_NO_LOCK:
{
Aast tmp874_AST = null;
tmp874_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp874_AST);
match(KW_NO_LOCK);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_WAIT) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp875_AST = null;
tmp875_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp875_AST);
match(KW_NO_WAIT);
}
else if ((LA(1)==KW_NO_PRE) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp876_AST = null;
tmp876_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp876_AST);
match(KW_NO_PRE);
}
else if ((LA(1)==KW_NO_ERROR) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp877_AST = null;
tmp877_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp877_AST);
match(KW_NO_ERROR);
}
else if ((LA(1)==KW_TAB_SCAN) && (_tokenSet_148.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp878_AST = null;
tmp878_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp878_AST);
match(KW_TAB_SCAN);
}
else {
break _loop1194;
}
} while (true);
}
currentRecord = oldRecord;
record_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_148);
}
returnAST = record_phrase_AST;
}
/**
* Support SQL <code>ALTER TABLE</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses the following rules:
* <p>
* <ul>
* <li> {@link #record}
* <li> {@link #sql_column_def}
* </ul>
*/
public final void alter_table_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast alter_table_stmt_AST = null;
Token a = null;
Aast a_AST = null;
try { // for error handling
NameNode nothing = null;
a = LT(1);
a_AST = (Aast)astFactory.create(a);
astFactory.makeASTRoot(currentAST, a_AST);
match(KW_ALTER);
a_AST.setType(ALTER_TABLE);
match(KW_TABLE);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
sql_column_def();
astFactory.addASTChild(currentAST, returnAST);
alter_table_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = alter_table_stmt_AST;
}
/**
* Matches the <code>CLOSE</code> keyword with a following {@link #symbol}.
* Called from {@link #embedded_sql}.
*/
public final void close_cursor_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast close_cursor_stmt_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CLOSE);
c_AST.setType(CLOSE_CURSOR);
symbol();
astFactory.addASTChild(currentAST, returnAST);
close_cursor_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = close_cursor_stmt_AST;
}
/**
* Matches the <code>CREATE INDEX</code> statement with a following
* {@link #symbol}, {@link #record} and one or more {@link #lvalue}.
* Called from {@link #embedded_sql}.
*/
public final void create_index_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_index_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token in = null;
Aast in_AST = null;
Token on = null;
Aast on_AST = null;
try { // for error handling
NameNode nothing = null;
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_INDEX);
{
switch ( LA(1)) {
case KW_UNIQUE:
{
Aast tmp880_AST = null;
tmp880_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp880_AST);
match(KW_UNIQUE);
break;
}
case KW_INDEX:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INDEX);
hide(in);
any_non_reserved_symbol();
astFactory.addASTChild(currentAST, returnAST);
on = LT(1);
on_AST = (Aast)astFactory.create(on);
match(KW_ON);
hide(on);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop514:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop514;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
create_index_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = create_index_stmt_AST;
}
/**
* Support SQL <code>CREATE TABLE</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses the following rules:
* <p>
* <ul>
* <li> {@link #symbol}
* <li> {@link #sql_column_spec}
* <li> {@link #sql_unique_index}
* </ul>
*/
public final void create_table_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_table_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token ta = null;
Aast ta_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_TABLE);
ta = LT(1);
ta_AST = (Aast)astFactory.create(ta);
match(KW_TABLE);
hide(ta);
symbol();
astFactory.addASTChild(currentAST, returnAST);
{
int _cnt517=0;
_loop517:
do {
if ((_tokenSet_151.member(LA(1)))) {
sql_column_spec(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_UNIQUE)) {
sql_unique_index();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt517>=1 ) { break _loop517; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt517++;
} while (true);
}
create_table_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = create_table_stmt_AST;
}
/**
* Support SQL <code>CREATE VIEW</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses the following rules:
* <p>
* <ul>
* <li> {@link #symbol}
* <li> {@link #sql_column_spec}
* <li> {@link #sql_unique_index}
* </ul>
*/
public final void create_view_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast create_view_stmt_AST = null;
Token c = null;
Aast c_AST = null;
Token vi = null;
Aast vi_AST = null;
Token as = null;
Aast as_AST = null;
Token w = null;
Aast w_AST = null;
Token ch = null;
Aast ch_AST = null;
Token op = null;
Aast op_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CREATE);
c_AST.setType(CREATE_VIEW);
vi = LT(1);
vi_AST = (Aast)astFactory.create(vi);
match(KW_VIEW);
hide(vi);
symbol();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case LPARENS:
{
sql_name_list(true);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_AS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
as = LT(1);
as_AST = (Aast)astFactory.create(as);
match(KW_AS);
hide(as);
select_stmt();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_WITH:
{
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.addASTChild(currentAST, w_AST);
match(KW_WITH);
w_AST.setType(WITH_CHECK_OPTION);
ch = LT(1);
ch_AST = (Aast)astFactory.create(ch);
match(KW_CHECK);
hide(ch);
op = LT(1);
op_AST = (Aast)astFactory.create(op);
match(KW_OPTION);
hide(op);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
create_view_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = create_view_stmt_AST;
}
/**
* Support SQL <code>DECLARE CURSOR</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses the following rules:
* <p>
* <ul>
* <li> {@link #symbol}
* <li> {@link #union_stmt}
* </ul>
*/
public final void declare_cursor_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast declare_cursor_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token cur = null;
Aast cur_AST = null;
Token f1 = null;
Aast f1_AST = null;
Token f2 = null;
Aast f2_AST = null;
Token r = null;
Aast r_AST = null;
Token on = null;
Aast on_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DECLARE);
d_AST.setType(DECLARE_CURSOR);
symbol();
astFactory.addASTChild(currentAST, returnAST);
cur = LT(1);
cur_AST = (Aast)astFactory.create(cur);
match(KW_CURSOR);
hide(cur);
f1 = LT(1);
f1_AST = (Aast)astFactory.create(f1);
match(KW_FOR);
hide(f1);
union_stmt();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_FOR:
{
f2 = LT(1);
f2_AST = (Aast)astFactory.create(f2);
match(KW_FOR);
hide(f2);
{
switch ( LA(1)) {
case KW_READ_ONL:
{
Aast tmp881_AST = null;
tmp881_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp881_AST);
match(KW_READ_ONL);
break;
}
case KW_READ:
{
{
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.addASTChild(currentAST, r_AST);
match(KW_READ);
{
switch ( LA(1)) {
case KW_ONLY:
{
on = LT(1);
on_AST = (Aast)astFactory.create(on);
match(KW_ONLY);
hide(on);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
r_AST.setType(KW_READ_ONL);
}
break;
}
case KW_UPDATE:
{
Aast tmp882_AST = null;
tmp882_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp882_AST);
match(KW_UPDATE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
declare_cursor_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = declare_cursor_stmt_AST;
}
/**
* Support SQL <code>DELETE FROM</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses the following rules:
* <p>
* <ul>
* <li> {@link #record}
* <li> {@link #where_clause}
* <li> {@link #where_current_of}
* </ul>
*/
public final void delete_from_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delete_from_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token fr = null;
Aast fr_AST = null;
try { // for error handling
NameNode nothing = null;
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DELETE);
d_AST.setType(DELETE_FROM);
fr = LT(1);
fr_AST = (Aast)astFactory.create(fr);
match(KW_FROM);
hide(fr);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_WHERE) && (LA(2)==KW_CURRENT) && (LA(3)==KW_OF)) {
where_current_of();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_WHERE) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
where_clause(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
delete_from_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = delete_from_stmt_AST;
}
/**
* Support SQL <code>DROP INDEX</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses {@link #symbol}.
*/
public final void drop_index_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast drop_index_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token in = null;
Aast in_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DROP);
d_AST.setType(DROP_INDEX);
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INDEX);
hide(in);
any_non_reserved_symbol();
astFactory.addASTChild(currentAST, returnAST);
drop_index_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = drop_index_stmt_AST;
}
/**
* Support SQL <code>DROP TABLE</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses {@link #record}.
*/
public final void drop_table_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast drop_table_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token ta = null;
Aast ta_AST = null;
try { // for error handling
NameNode nothing = null;
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DROP);
d_AST.setType(DROP_TABLE);
ta = LT(1);
ta_AST = (Aast)astFactory.create(ta);
match(KW_TABLE);
hide(ta);
nothing=record(false, false, false);
astFactory.addASTChild(currentAST, returnAST);
drop_table_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = drop_table_stmt_AST;
}
/**
* Support SQL <code>DROP VIEW</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses {@link #symbol}.
*/
public final void drop_view_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast drop_view_stmt_AST = null;
Token d = null;
Aast d_AST = null;
Token vi = null;
Aast vi_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DROP);
d_AST.setType(DROP_VIEW);
vi = LT(1);
vi_AST = (Aast)astFactory.create(vi);
match(KW_VIEW);
hide(vi);
symbol();
astFactory.addASTChild(currentAST, returnAST);
drop_view_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = drop_view_stmt_AST;
}
/**
* Support SQL <code>FETCH</code> directly in 4GL code. Called from
* {@link #embedded_sql}. Uses {@link #symbol} and {@link #sql_into}.
*/
public final void fetch_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast fetch_stmt_AST = null;
try { // for error handling
Aast tmp883_AST = null;
tmp883_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp883_AST);
match(KW_FETCH);
symbol();
astFactory.addASTChild(currentAST, returnAST);
sql_into();
astFactory.addASTChild(currentAST, returnAST);
fetch_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = fetch_stmt_AST;
}
/**
* Support SQL <code>GRANT</code> directly in 4GL code. Called from
* {@link #embedded_sql}. Uses {@link #sql_update_rights},
* {@link #sql_on_table} and {@link #sql_to_from_users}.
*/
public final void grant_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast grant_stmt_AST = null;
Token pr = null;
Aast pr_AST = null;
Token w = null;
Aast w_AST = null;
Token gr = null;
Aast gr_AST = null;
Token op = null;
Aast op_AST = null;
try { // for error handling
Aast tmp884_AST = null;
tmp884_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp884_AST);
match(KW_GRANT);
{
int _cnt535=0;
_loop535:
do {
switch ( LA(1)) {
case KW_ALL:
{
Aast tmp885_AST = null;
tmp885_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp885_AST);
match(KW_ALL);
{
switch ( LA(1)) {
case KW_PRIVILEG:
{
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PRIVILEG);
hide(pr);
break;
}
case KW_ALL:
case KW_DELETE:
case KW_INSERT:
case KW_ON:
case KW_SELECT:
case KW_UPDATE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_SELECT:
{
Aast tmp886_AST = null;
tmp886_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp886_AST);
match(KW_SELECT);
break;
}
case KW_INSERT:
{
Aast tmp887_AST = null;
tmp887_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp887_AST);
match(KW_INSERT);
break;
}
case KW_DELETE:
{
Aast tmp888_AST = null;
tmp888_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp888_AST);
match(KW_DELETE);
break;
}
case KW_UPDATE:
{
sql_update_rights();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
if ( _cnt535>=1 ) { break _loop535; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt535++;
} while (true);
}
sql_on_table();
astFactory.addASTChild(currentAST, returnAST);
sql_to_from_users();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_WITH:
{
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.addASTChild(currentAST, w_AST);
match(KW_WITH);
w_AST.setType(WITH_GRANT_OPTION);
gr = LT(1);
gr_AST = (Aast)astFactory.create(gr);
match(KW_GRANT);
hide(gr);
op = LT(1);
op_AST = (Aast)astFactory.create(op);
match(KW_OPTION);
hide(op);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
grant_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = grant_stmt_AST;
}
/**
* Support SQL <code>INSERT INTO</code> directly in 4GL code. Called from
* {@link #embedded_sql}. Uses {@link #record}, {@link #select_stmt},
* {@link #sql_simple_column_list} and {@link #sql_value_list}.
*/
public final void insert_into_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast insert_into_stmt_AST = null;
Token i = null;
Aast i_AST = null;
Token in = null;
Aast in_AST = null;
try { // for error handling
NameNode nothing = null;
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.addASTChild(currentAST, i_AST);
match(KW_INSERT);
i_AST.setType(INSERT_INTO);
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INTO);
hide(in);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case LPARENS:
{
sql_simple_column_list();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SELECT:
case KW_VALUES:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_VALUES:
{
sql_value_list();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SELECT:
{
select_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
insert_into_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = insert_into_stmt_AST;
}
/**
* Matches the <code>OPEN</code> keyword with a following {@link #symbol}.
* Called from {@link #embedded_sql}.
*/
public final void open_cursor_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast open_cursor_stmt_AST = null;
Token o = null;
Aast o_AST = null;
try { // for error handling
o = LT(1);
o_AST = (Aast)astFactory.create(o);
astFactory.makeASTRoot(currentAST, o_AST);
match(KW_OPEN);
o_AST.setType(OPEN_CURSOR);
symbol();
astFactory.addASTChild(currentAST, returnAST);
open_cursor_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = open_cursor_stmt_AST;
}
/**
* Support SQL <code>REVOKE</code> directly in 4GL code. Called from
* {@link #embedded_sql}. Uses {@link #sql_update_rights},
* {@link #sql_on_table} and {@link #sql_to_from_users}.
*/
public final void revoke_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast revoke_stmt_AST = null;
Token pr = null;
Aast pr_AST = null;
try { // for error handling
Aast tmp889_AST = null;
tmp889_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp889_AST);
match(KW_REVOKE);
{
int _cnt544=0;
_loop544:
do {
switch ( LA(1)) {
case KW_ALL:
{
Aast tmp890_AST = null;
tmp890_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp890_AST);
match(KW_ALL);
{
switch ( LA(1)) {
case KW_PRIVILEG:
{
pr = LT(1);
pr_AST = (Aast)astFactory.create(pr);
match(KW_PRIVILEG);
hide(pr);
break;
}
case KW_ALL:
case KW_DELETE:
case KW_INSERT:
case KW_ON:
case KW_SELECT:
case KW_UPDATE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_SELECT:
{
Aast tmp891_AST = null;
tmp891_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp891_AST);
match(KW_SELECT);
break;
}
case KW_INSERT:
{
Aast tmp892_AST = null;
tmp892_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp892_AST);
match(KW_INSERT);
break;
}
case KW_DELETE:
{
Aast tmp893_AST = null;
tmp893_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp893_AST);
match(KW_DELETE);
break;
}
case KW_UPDATE:
{
sql_update_rights();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
if ( _cnt544>=1 ) { break _loop544; } else {throw new NoViableAltException(LT(1), getFilename());}
}
}
_cnt544++;
} while (true);
}
sql_on_table();
astFactory.addASTChild(currentAST, returnAST);
sql_to_from_users();
astFactory.addASTChild(currentAST, returnAST);
revoke_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = revoke_stmt_AST;
}
/**
* Matches the SQL <code>UNION</code> statement which can be the same as a
* simple {@link #select_stmt}, or it can contain a nested set of select
* statements joined by the <code>UNION</code> keyword. There is no limit
* to the number of select statements joined in a union. Note that if a
* union is active, then any {@link #sql_order_by} clause will attach to
* the top-level union statement node rather than to any of the select
* statements. Called by {@link #embedded_sql}.
*/
public final void union_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast union_stmt_AST = null;
try { // for error handling
sqlNestLevel++;
select_stmt();
astFactory.addASTChild(currentAST, returnAST);
{
_loop554:
do {
if ((LA(1)==KW_UNION) && (LA(2)==KW_ALL||LA(2)==KW_SELECT) && (_tokenSet_152.member(LA(3)))) {
Aast tmp894_AST = null;
tmp894_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp894_AST);
match(KW_UNION);
inUnion = true;
{
switch ( LA(1)) {
case KW_ALL:
{
Aast tmp895_AST = null;
tmp895_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp895_AST);
match(KW_ALL);
break;
}
case KW_SELECT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
union_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop554;
}
} while (true);
}
{
if (((LA(1)==KW_ORDER) && (LA(2)==KW_BY) && (_tokenSet_24.member(LA(3))))&&( inUnion && sqlNestLevel == 1 )) {
sql_order_by();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_153.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sqlNestLevel--;
union_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_153);
}
returnAST = union_stmt_AST;
}
/**
* Matches the SQL <code>UPDATE</code> statement. Uses {@link #record},
* {@link #sql_assign_list}, {@link #where_clause} and
* {@link #where_current_of}. Called by {@link #embedded_sql}.
*/
public final void sql_update_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_update_stmt_AST = null;
Token u = null;
Aast u_AST = null;
try { // for error handling
NameNode nothing = null;
u = LT(1);
u_AST = (Aast)astFactory.create(u);
astFactory.makeASTRoot(currentAST, u_AST);
match(KW_UPDATE);
u_AST.setType(UPDATE_SQL);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
sql_assign_list();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_WHERE) && (LA(2)==KW_CURRENT) && (LA(3)==KW_OF)) {
where_current_of();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_WHERE) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
where_clause(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_update_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = sql_update_stmt_AST;
}
/**
* Matches the <code>ADD</code>, <code>DROP</code> or <code>ALTER</code>
* specification for an {@link #alter_table_stmt}. Uses the following:
* <p>
* <ul>
* <li> {@link #sql_data_type}
* <li> {@link #record}
* <li> {@link #sql_default_value}
* <li> {@link #label}
* <li> {@link #format_string}
* <li> {@link #column_label}
* <li> {@link #case_sensitive}
* </ul>
*/
public final void sql_column_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_column_def_AST = null;
Token co = null;
Aast co_AST = null;
try { // for error handling
boolean add = false;
boolean drop = false;
NameNode nothing = null;
{
switch ( LA(1)) {
case KW_ADD:
{
Aast tmp896_AST = null;
tmp896_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp896_AST);
match(KW_ADD);
add = true;
break;
}
case KW_DROP:
{
Aast tmp897_AST = null;
tmp897_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp897_AST);
match(KW_DROP);
drop = true;
break;
}
case KW_ALTER:
{
Aast tmp898_AST = null;
tmp898_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp898_AST);
match(KW_ALTER);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
co = LT(1);
co_AST = (Aast)astFactory.create(co);
match(KW_COL);
hide(co);
{
if (((_tokenSet_151.member(LA(1))) && (_tokenSet_154.member(LA(2))))&&( add )) {
sql_column_spec(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_155.member(LA(2)))) {
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_156.member(LA(1))))&&( !drop )) {
sql_column_options();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DOT)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_column_def_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = sql_column_def_AST;
}
/**
* Matches a column name as a {@link #symbol} and the following data type
* as {@link #sql_data_type}. Called by {@link #sql_column_def} and
* {@link #create_table_stmt}.
*/
public final void sql_column_spec(
boolean root
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_column_spec_AST = null;
Token d = null;
Aast d_AST = null;
try { // for error handling
if (root)
{
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(KW_COL,""));
}
{
if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==DB_SYMBOL)) {
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.addASTChild(currentAST, d_AST);
match(DB_SYMBOL);
d_AST.setType(SYMBOL);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_data_type();
astFactory.addASTChild(currentAST, returnAST);
sql_column_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_157);
}
returnAST = sql_column_spec_AST;
}
/**
* Matches <code>UNIQUE</code> followed by a parenthesized list of column
* names using {@link #sql_column_list}. This is a unique index definition.
* Called by {@link #create_table_stmt}.
*/
public final void sql_unique_index() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_unique_index_AST = null;
try { // for error handling
Aast tmp899_AST = null;
tmp899_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp899_AST);
match(KW_UNIQUE);
sql_name_list(false);
astFactory.addASTChild(currentAST, returnAST);
sql_unique_index_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_158);
}
returnAST = sql_unique_index_AST;
}
/**
* Matches a parenthesized list of column names as {@link #symbol}. Called
* by {@link #sql_unique_index} and {@link #create_view_stmt}.
*/
public final void sql_name_list(
boolean root
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_name_list_AST = null;
try { // for error handling
if (root)
{
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(KW_COLUMNS,""));
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
symbol();
astFactory.addASTChild(currentAST, returnAST);
{
_loop597:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop597;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sql_name_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_159);
}
returnAST = sql_name_list_AST;
}
/**
* Support SQL <code>SELECT</code> directly in 4GL code. Called from
* {@link #embedded_sql} and uses the following rules:
* <p>
* <ul>
* <li> {@link #sql_column_list}
* <li> {@link #sql_into}
* <li> {@link #sql_from}
* <li> {@link #where_clause}
* <li> {@link #sql_group_by}
* <li> {@link #sql_having}
* <li> {@link #sql_order_by}
* <li> {@link #frame_phrase}
* </ul>
*/
public final void select_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast select_stmt_AST = null;
Aast cl_AST = null;
try { // for error handling
selectNestLevel++;
Aast tmp900_AST = null;
tmp900_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp900_AST);
match(KW_SELECT);
{
if ((LA(1)==KW_ALL) && (_tokenSet_152.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp901_AST = null;
tmp901_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp901_AST);
match(KW_ALL);
}
else if ((LA(1)==KW_DISTINCT) && (_tokenSet_152.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp902_AST = null;
tmp902_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp902_AST);
match(KW_DISTINCT);
}
else if ((_tokenSet_152.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==MULTIPLY)) {
Aast tmp903_AST = null;
tmp903_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp903_AST);
match(MULTIPLY);
}
else if ((_tokenSet_24.member(LA(1)))) {
sql_column_list();
cl_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_INTO:
{
sql_into();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FROM:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
sql_from();
astFactory.addASTChild(currentAST, returnAST);
// the field list may have symbols that couldn't be resolved because
// they were qualified with SQL correlation names that are only
// defined during the FROM clause processing; fix these up as proper
// fields now that the FROM clause buffer processing is complete
if (cl_AST != null)
{
Iterator iter = cl_AST.iterator();
while (iter.hasNext())
{
Aast next = (Aast) iter.next();
if (next.getType() == SYMBOL && sym.isField(next.getText()))
{
sym.annotateField(next, null, true, true);
}
}
}
{
_loop550:
do {
switch ( LA(1)) {
case KW_WHERE:
{
where_clause(true);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_GROUP:
{
sql_group_by();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_HAVING:
{
sql_having();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if (((LA(1)==KW_ORDER) && (LA(2)==KW_BY) && (_tokenSet_24.member(LA(3))))&&( !inUnion )) {
sql_order_by();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_WITH) && (_tokenSet_112.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(2) != KW_CHECK && LA(3) != KW_OPTION )) {
frame_phrase(false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop550;
}
}
} while (true);
}
selectNestLevel--;
select_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_160);
}
returnAST = select_stmt_AST;
}
/**
* Matches the <code>WHERE CURRENT OF</code> keyword sequence and a following
* {@link #symbol}. Used by {@link #delete_from_stmt}.
*/
public final void where_current_of() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast where_current_of_AST = null;
Token w = null;
Aast w_AST = null;
Token cur = null;
Aast cur_AST = null;
Token of = null;
Aast of_AST = null;
try { // for error handling
w = LT(1);
w_AST = (Aast)astFactory.create(w);
astFactory.makeASTRoot(currentAST, w_AST);
match(KW_WHERE);
w_AST.setType(WHERE_CURRENT_OF);
cur = LT(1);
cur_AST = (Aast)astFactory.create(cur);
match(KW_CURRENT);
hide(cur);
of = LT(1);
of_AST = (Aast)astFactory.create(of);
match(KW_OF);
hide(of);
symbol();
astFactory.addASTChild(currentAST, returnAST);
where_current_of_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = where_current_of_AST;
}
/**
* Matches the <code>WHERE</code> keyword and the required following
* expression. Note that the expression processing that is exposed via the
* {@link #expr} rule has been modified to support the <code>CONTAINS</code>
* operator. This operator is specific in usage to the where clause and
* follows a form of:
* <pre>
* field CONTAINS expression
* </pre>
* <p>
* This support is implemented in {@link #compare_expr} which means that
* the <code>CONTAINS</code> operator has the same precedence as operators
* <code>BEGINS, MATCHES</code> and other comparisons. For more details on
* how <code>CONTAINS</code> works, please see page 960 in the Progress 4GL
* language reference. <b>Note that placing the operator support inside the
* general purpose expression processing was required to resolve
* ambiguity!</b> This makes sense since <code>CONTAINS</code> <b>is</b> an
* operator and thus its operands are naturally conflicting with other
* operators. The ambiguity would be a problem in certain cases (invoving
* the <code>LBRACKET</code> array syntax in {@link #lvalue} if we attempted
* to separate the <code>CONTAINS</code> processing into this location.
* <p>
* Though undocumented, customer code was found in which the following
* expression was optional! This compiled without problem though it is
* nonsense (in this case, the <code>WHERE</code> must be ignored). This
* feature causes ambiguity warnings which have been disabled.
* <p>
* Used by {@link #record_phrase} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*
* @param sql
* Flag indicating if this is matching from a SQL statement.
*/
public final void where_clause(
boolean sql
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast where_clause_AST = null;
try { // for error handling
Aast tmp904_AST = null;
tmp904_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp904_AST);
match(KW_WHERE);
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( !isValidBlockHeaderOrQueryKeyword(sql) )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_148.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
where_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_148);
}
returnAST = where_clause_AST;
}
/**
* Matches an embedded SQL <code>INTO</code> clause and the following list
* of variables (uses {@link #lvalue} and {@link #sql_indicator_var}).
*/
public final void sql_into() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_into_AST = null;
try { // for error handling
Aast tmp905_AST = null;
tmp905_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp905_AST);
match(KW_INTO);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_INDICAT:
{
sql_indicator_var();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FROM:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop638:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_INDICAT:
{
sql_indicator_var();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FROM:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop638;
}
} while (true);
}
sql_into_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_161);
}
returnAST = sql_into_AST;
}
/**
* Matches SQL <code>UPDATE</code> rights option with a list of columns
* using {@link #lvalue}. Used by {@link #grant_stmt}.
*/
public final void sql_update_rights() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_update_rights_AST = null;
try { // for error handling
Aast tmp906_AST = null;
tmp906_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp906_AST);
match(KW_UPDATE);
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop580:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop580;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sql_update_rights_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_162);
}
returnAST = sql_update_rights_AST;
}
/**
* Matches SQL <code>ON</code> followed by a {@link #record}. Used by
* {@link #grant_stmt}.
*/
public final void sql_on_table() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_on_table_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp907_AST = null;
tmp907_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp907_AST);
match(KW_ON);
nothing=record(false, false, false);
astFactory.addASTChild(currentAST, returnAST);
sql_on_table_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_163);
}
returnAST = sql_on_table_AST;
}
/**
* Matches SQL <code>TO</code> or <code>FROM</code> rights option with a list
* of users as {@link #symbol} or the keyword <code>PUBLIC</code>. Used by
* {@link #grant_stmt} and {@link #revoke_stmt}.
*/
public final void sql_to_from_users() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_to_from_users_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_TO:
{
Aast tmp908_AST = null;
tmp908_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp908_AST);
match(KW_TO);
break;
}
case KW_FROM:
{
Aast tmp909_AST = null;
tmp909_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp909_AST);
match(KW_FROM);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_PUBLIC) && (LA(2)==DOT||LA(2)==KW_WITH) && (_tokenSet_11.member(LA(3)))) {
Aast tmp910_AST = null;
tmp910_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp910_AST);
match(KW_PUBLIC);
}
else if ((_tokenSet_15.member(LA(1))) && (LA(2)==DOT||LA(2)==KW_WITH||LA(2)==COMMA) && (_tokenSet_11.member(LA(3)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
{
_loop586:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop586;
}
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_to_from_users_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_99);
}
returnAST = sql_to_from_users_AST;
}
/**
* Matches the list of fields in a {@link #insert_into_stmt}. Uses
* {@link #lvalue}.
*/
public final void sql_simple_column_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_simple_column_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(COLUMN_LIST,""));
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop572:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop572;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sql_simple_column_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_164);
}
returnAST = sql_simple_column_list_AST;
}
/**
* Matches the list of values in a {@link #insert_into_stmt}. Uses
* {@link #expr}.
*/
public final void sql_value_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_value_list_AST = null;
try { // for error handling
Aast tmp911_AST = null;
tmp911_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp911_AST);
match(KW_VALUES);
lparens();
astFactory.addASTChild(currentAST, returnAST);
sql_value();
astFactory.addASTChild(currentAST, returnAST);
{
_loop575:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
sql_value();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop575;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sql_value_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = sql_value_list_AST;
}
/**
* Matches the list of fields or SQL aggregate functions in a
* {@link #select_stmt}. Uses {@link #sql_individual_column}.
*/
public final void sql_column_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_column_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(COLUMN_LIST,""));
sql_individual_column();
astFactory.addASTChild(currentAST, returnAST);
{
_loop610:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
sql_individual_column();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop610;
}
} while (true);
}
sql_column_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_165);
}
returnAST = sql_column_list_AST;
}
/**
* Matches an embedded SQL <code>FROM</code> clause and the following
* {@link #sql_table_spec}.
*/
public final void sql_from() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_from_AST = null;
try { // for error handling
Aast tmp912_AST = null;
tmp912_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp912_AST);
match(KW_FROM);
sql_table_spec();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_166.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
_loop622:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
sql_table_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop622;
}
} while (true);
}
}
else if ((_tokenSet_167.member(LA(1)))) {
sql_explicit_join();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_168.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_from_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_168);
}
returnAST = sql_from_AST;
}
/**
* Matches the SQL <code>GROUP BY</code> specification and its following
* list of comma separated {@link #expr}. Called by {@link #select_stmt}.
*/
public final void sql_group_by() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_group_by_AST = null;
Token g = null;
Aast g_AST = null;
Token by = null;
Aast by_AST = null;
try { // for error handling
g = LT(1);
g_AST = (Aast)astFactory.create(g);
astFactory.makeASTRoot(currentAST, g_AST);
match(KW_GROUP);
g_AST.setType(GROUP_BY);
by = LT(1);
by_AST = (Aast)astFactory.create(by);
match(KW_BY);
hide(by);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop642:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop642;
}
} while (true);
}
sql_group_by_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_168);
}
returnAST = sql_group_by_AST;
}
/**
* Matches the SQL <code>HAVING</code> keyword and its following
* {@link #expr}. Called by {@link #select_stmt}.
*/
public final void sql_having() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_having_AST = null;
try { // for error handling
Aast tmp913_AST = null;
tmp913_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp913_AST);
match(KW_HAVING);
expr();
astFactory.addASTChild(currentAST, returnAST);
sql_having_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_168);
}
returnAST = sql_having_AST;
}
/**
* Matches the SQL <code>ORDER BY</code> specification and its following
* list of comma separated {@link #expr} and optional
* {@link #sql_direction_spec}. Called by {@link #select_stmt}.
*/
public final void sql_order_by() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_order_by_AST = null;
Token o = null;
Aast o_AST = null;
Token by = null;
Aast by_AST = null;
try { // for error handling
o = LT(1);
o_AST = (Aast)astFactory.create(o);
astFactory.makeASTRoot(currentAST, o_AST);
match(KW_ORDER);
o_AST.setType(ORDER_BY);
by = LT(1);
by_AST = (Aast)astFactory.create(by);
match(KW_BY);
hide(by);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_ASC:
case KW_DESCEND:
{
sql_direction_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FOR:
case KW_GROUP:
case KW_HAVING:
case KW_UNION:
case KW_WHERE:
case KW_WITH:
case KW_ORDER:
case COMMA:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop648:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_ASC:
case KW_DESCEND:
{
sql_direction_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FOR:
case KW_GROUP:
case KW_HAVING:
case KW_UNION:
case KW_WHERE:
case KW_WITH:
case KW_ORDER:
case COMMA:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop648;
}
} while (true);
}
sql_order_by_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_168);
}
returnAST = sql_order_by_AST;
}
/**
* Matches the list of column assignments in an {@link #sql_update_stmt}
* which are rooted at a <code>SET</code> keyword.
*/
public final void sql_assign_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_assign_list_AST = null;
try { // for error handling
Aast tmp914_AST = null;
tmp914_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp914_AST);
match(KW_SET);
sql_assign();
astFactory.addASTChild(currentAST, returnAST);
{
_loop568:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
sql_assign();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop568;
}
} while (true);
}
sql_assign_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_169);
}
returnAST = sql_assign_list_AST;
}
/**
* Matches a sub-select in a <code>WHERE</code> clause.
*/
public final void sub_select_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sub_select_stmt_AST = null;
Token n = null;
Aast n_AST = null;
Token exi = null;
Aast exi_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_ANY:
{
Aast tmp915_AST = null;
tmp915_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp915_AST);
match(KW_ANY);
break;
}
case KW_ALL:
{
Aast tmp916_AST = null;
tmp916_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp916_AST);
match(KW_ALL);
break;
}
case KW_SOME:
{
Aast tmp917_AST = null;
tmp917_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp917_AST);
match(KW_SOME);
break;
}
case KW_EXISTS:
{
Aast tmp918_AST = null;
tmp918_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp918_AST);
match(KW_EXISTS);
break;
}
case KW_NOT:
{
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.makeASTRoot(currentAST, n_AST);
match(KW_NOT);
exi = LT(1);
exi_AST = (Aast)astFactory.create(exi);
match(KW_EXISTS);
hide(exi); n_AST.setType(NOT_EXISTS);
break;
}
case LPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
select_stmt();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
sub_select_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = sub_select_stmt_AST;
}
/**
* Matches a sub-select in a <code>WHERE</code> clause that is based on the
* <code>IN</code> operator.
*/
public final void in_operator_sub_select_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_operator_sub_select_stmt_AST = null;
Token n = null;
Aast n_AST = null;
Token in = null;
Aast in_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_NOT:
{
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.makeASTRoot(currentAST, n_AST);
match(KW_NOT);
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_IN);
hide(in); n_AST.setType(NOT_IN);
break;
}
case KW_IN:
{
Aast tmp919_AST = null;
tmp919_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp919_AST);
match(KW_IN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
in_operator_parms();
astFactory.addASTChild(currentAST, returnAST);
in_operator_sub_select_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = in_operator_sub_select_stmt_AST;
}
/**
* Matches the value list or sub-select portion of an <code>IN</code>
* operator.
*/
public final void in_operator_parms() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_operator_parms_AST = null;
try { // for error handling
Aast tmp920_AST = null;
tmp920_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp920_AST);
match(LPARENS);
{
if ((LA(1)==KW_SELECT) && (_tokenSet_152.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
select_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
sum_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop565:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
sum_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop565;
}
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
in_operator_parms_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = in_operator_parms_AST;
}
/**
* Implements the 6th precedence level of Progress 4GL expressions, the
* <code>PLUS</code> and <code>MINUS</code> operators (for all data types,
* even the non-numeric uses for dates or string concatenation).
* <p>
* This is only called by the 4th level {@link #compare_expr} rule. This
* method subsequently calls the {@link #prod_expr} rule.
* <p>
* There is a bogus ambiguity warning generated by this rule (which occurs
* because of the addition of the special <code>IF THEN ELSE</code> function
* (see {@link #if_func}) in the {@link #primary_expr} rule. No real ambiguity
* seems to exist and no errors can be found, so warnings have been disabled.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
*/
public final void sum_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sum_expr_AST = null;
try { // for error handling
prod_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1665:
do {
if ((LA(1)==MINUS||LA(1)==PLUS) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case PLUS:
{
Aast tmp921_AST = null;
tmp921_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp921_AST);
match(PLUS);
break;
}
case MINUS:
{
Aast tmp922_AST = null;
tmp922_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp922_AST);
match(MINUS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
matchAssign = false;
prod_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1665;
}
} while (true);
}
sum_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = sum_expr_AST;
}
/**
* Matches the SQL assignment of an {@link #sql_value} to an {@link #lvalue}.
* Called by {@link #sql_assign_list}.
*/
public final void sql_assign() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_assign_AST = null;
Token eq = null;
Aast eq_AST = null;
try { // for error handling
lvalue();
astFactory.addASTChild(currentAST, returnAST);
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(EQUALS);
eq_AST.setType(ASSIGN);
sql_value();
astFactory.addASTChild(currentAST, returnAST);
sql_assign_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_170);
}
returnAST = sql_assign_AST;
}
/**
* Matches a single {@link #expr} or <code>KW_NULL</code>. Used in
* {@link #sql_value_list} and {@link #sql_update_stmt}.
*/
public final void sql_value() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_value_AST = null;
try { // for error handling
{
if ((LA(1)==KW_NULL) && (_tokenSet_171.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
Aast tmp923_AST = null;
tmp923_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp923_AST);
match(KW_NULL);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_value_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_171);
}
returnAST = sql_value_AST;
}
/**
* Matches the possible clauses to define column attributes or options.
* Uses the following:
* <p>
* <ul>
* <li> {@link #sql_default_value}
* <li> {@link #label}
* <li> {@link #format_string}
* <li> {@link #column_label}
* <li> {@link #case_sensitive}
* <li> {@link #sql_not_null}
* </ul>
*/
public final void sql_column_options() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_column_options_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_DEFAULT:
{
sql_default_value();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LABEL:
{
label(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FORMAT:
{
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_COL_LAB:
{
column_label();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((LA(1)==KW_CASE_SEN||LA(1)==KW_NOT) && (LA(2)==DOT||LA(2)==KW_CASE_SEN)) {
case_sensitive();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NOT) && (LA(2)==KW_NULL)) {
sql_not_null();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
sql_column_options_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = sql_column_options_AST;
}
/**
* Matches all possible SQL data types.
* <p>
* <pre>
* CHARACTER
* DECIMAL
* DATE
* DOUBLE
* FLOAT
* INTEGER
* LOGICAL
* NUMERIC
* REAL
* SMALLINT
* </pre>
*/
public final void sql_data_type() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_data_type_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_CHAR:
{
Aast tmp924_AST = null;
tmp924_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp924_AST);
match(KW_CHAR);
break;
}
case KW_DEC:
{
Aast tmp925_AST = null;
tmp925_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp925_AST);
match(KW_DEC);
break;
}
case KW_DATE:
{
Aast tmp926_AST = null;
tmp926_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp926_AST);
match(KW_DATE);
break;
}
case KW_DOUBLE:
{
Aast tmp927_AST = null;
tmp927_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp927_AST);
match(KW_DOUBLE);
break;
}
case KW_FLOAT:
{
Aast tmp928_AST = null;
tmp928_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp928_AST);
match(KW_FLOAT);
break;
}
case KW_INT:
{
Aast tmp929_AST = null;
tmp929_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp929_AST);
match(KW_INT);
break;
}
case KW_LOGICAL:
{
Aast tmp930_AST = null;
tmp930_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp930_AST);
match(KW_LOGICAL);
break;
}
case KW_NUMERIC:
{
Aast tmp931_AST = null;
tmp931_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp931_AST);
match(KW_NUMERIC);
break;
}
case KW_REAL:
{
Aast tmp932_AST = null;
tmp932_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp932_AST);
match(KW_REAL);
break;
}
case KW_SMALLINT:
{
Aast tmp933_AST = null;
tmp933_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp933_AST);
match(KW_SMALLINT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LPARENS)) {
sql_data_option();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_157.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_data_type_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_157);
}
returnAST = sql_data_type_AST;
}
/**
* Matches the <code>DEFAULT</code> keyword and the following literal. Used
* by {@link #sql_column_options}.
*/
public final void sql_default_value() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_default_value_AST = null;
try { // for error handling
Aast tmp934_AST = null;
tmp934_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp934_AST);
match(KW_DEFAULT);
literal();
astFactory.addASTChild(currentAST, returnAST);
sql_default_value_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = sql_default_value_AST;
}
/**
* Matches the <code>NOT NULL</code> keywords and the optional following
* <code>UNIQUE</code>. Used by {@link #sql_column_options}.
*/
public final void sql_not_null() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_not_null_AST = null;
Token n = null;
Aast n_AST = null;
Token nu = null;
Aast nu_AST = null;
try { // for error handling
n = LT(1);
n_AST = (Aast)astFactory.create(n);
astFactory.makeASTRoot(currentAST, n_AST);
match(KW_NOT);
n_AST.setType(NOT_NULL);
nu = LT(1);
nu_AST = (Aast)astFactory.create(nu);
match(KW_NULL);
hide(nu);
{
switch ( LA(1)) {
case KW_UNIQUE:
{
Aast tmp935_AST = null;
tmp935_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp935_AST);
match(KW_UNIQUE);
break;
}
case DOT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
sql_not_null_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = sql_not_null_AST;
}
/**
* Matches limited options (for column data type specifiers) as numeric
* literals in parenthesis. Called by {@link #sql_data_type}.
*/
public final void sql_data_option() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_data_option_AST = null;
try { // for error handling
Aast tmp936_AST = null;
tmp936_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp936_AST);
match(LPARENS);
literal();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sql_data_option_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_157);
}
returnAST = sql_data_option_AST;
}
/**
* Matches a single field or expression (including SQL aggregate functions) in
* a {@link #sql_column_list}. Uses {@link #expr}, {@link #format_phrase} and
* {@link #any_non_reserved_symbol}. The symbol processing is needed to
* match on qualified field names that reference aliased table names
* (a "SQL correlation name").
*/
public final void sql_individual_column() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_individual_column_AST = null;
try { // for error handling
{
if (((_tokenSet_53.member(LA(1))) && (_tokenSet_172.member(LA(2))) && (_tokenSet_173.member(LA(3))))&&( !sym.isField(LT(1).getText()) )) {
any_non_reserved_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((_tokenSet_172.member(LA(1))) && (_tokenSet_173.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
format_phrase(null, null, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_FROM||LA(1)==KW_INTO||LA(1)==COMMA) && (_tokenSet_58.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_individual_column_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_174);
}
returnAST = sql_individual_column_AST;
}
/**
* Matches an embedded SQL aggregate function call. The following are
* supported:
* <p>
* <pre>
* AVG
* COUNT
* MAX
* MIN
* SUM
* </pre>
*/
public final void sql_aggregate_funcs() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_aggregate_funcs_AST = null;
Token m = null;
Aast m_AST = null;
try { // for error handling
boolean count = false;
{
switch ( LA(1)) {
case KW_AVG:
{
Aast tmp937_AST = null;
tmp937_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp937_AST);
match(KW_AVG);
break;
}
case KW_COUNT:
{
Aast tmp938_AST = null;
tmp938_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp938_AST);
match(KW_COUNT);
count = true;
break;
}
case KW_MAX:
{
Aast tmp939_AST = null;
tmp939_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp939_AST);
match(KW_MAX);
break;
}
case KW_MIN:
{
Aast tmp940_AST = null;
tmp940_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp940_AST);
match(KW_MIN);
break;
}
case KW_SUM:
{
Aast tmp941_AST = null;
tmp941_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp941_AST);
match(KW_SUM);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==MULTIPLY))&&( count )) {
m = LT(1);
m_AST = (Aast)astFactory.create(m);
astFactory.addASTChild(currentAST, m_AST);
match(MULTIPLY);
saveAndReplaceTypeAndText(m_AST, STRING, "\"" + m_AST.getText() + "\"");
}
else if ((_tokenSet_24.member(LA(1)))) {
{
if ((LA(1)==KW_DISTINCT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp942_AST = null;
tmp942_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp942_AST);
match(KW_DISTINCT);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_53.member(LA(1))) && (LA(2)==RPARENS) && (_tokenSet_3.member(LA(3))))&&( !sym.isField(LT(1).getText()) )) {
any_non_reserved_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sql_aggregate_funcs_AST = (Aast)currentAST.root;
saveAndReplaceType(sql_aggregate_funcs_AST, count ? FUNC_INT : FUNC_POLY);
// manually write our function-specific annotations
sql_aggregate_funcs_AST.putAnnotation("builtin", Boolean.valueOf(true));
sql_aggregate_funcs_AST.putAnnotation("sql", Boolean.valueOf(true));
sql_aggregate_funcs_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = sql_aggregate_funcs_AST;
}
/**
* Matches a {@link #record} and an optional following
* {@link #sql_correlation_name}. Used from {@link #sql_from}.
*/
public final void sql_table_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_table_spec_AST = null;
Aast r_AST = null;
try { // for error handling
NameNode nothing = null;
nothing=record(true, false, false);
r_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_15.member(LA(1))) && (_tokenSet_175.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
sql_correlation_name(r_AST.getText());
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_175.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
sql_table_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_175);
}
returnAST = sql_table_spec_AST;
}
/**
* Matches all 3 kinds of explicit join (inner joins, left outer joins and
* right outer joins). Uses {@link #sql_table_spec} and
* {@link #sql_join_condition}. Used by {@link #sql_from}.
*/
public final void sql_explicit_join() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_explicit_join_AST = null;
Token r = null;
Aast r_AST = null;
Token ou = null;
Aast ou_AST = null;
Token jo = null;
Aast jo_AST = null;
Token in = null;
Aast in_AST = null;
Token l = null;
Aast l_AST = null;
Token out = null;
Aast out_AST = null;
Token j = null;
Aast j_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_RIGHT:
{
r = LT(1);
r_AST = (Aast)astFactory.create(r);
astFactory.makeASTRoot(currentAST, r_AST);
match(KW_RIGHT);
r_AST.setType(RIGHT_OUTER_JOIN);
{
switch ( LA(1)) {
case KW_OUTER:
{
ou = LT(1);
ou_AST = (Aast)astFactory.create(ou);
match(KW_OUTER);
hide(ou);
break;
}
case KW_JOIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
jo = LT(1);
jo_AST = (Aast)astFactory.create(jo);
match(KW_JOIN);
hide(jo);
sql_table_spec();
astFactory.addASTChild(currentAST, returnAST);
sql_join_condition();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_JOIN:
case KW_INNER:
case KW_LEFT:
{
{
int _cnt629=0;
_loop629:
do {
if ((LA(1)==KW_JOIN||LA(1)==KW_INNER||LA(1)==KW_LEFT)) {
{
switch ( LA(1)) {
case KW_INNER:
{
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INNER);
hide(in);
break;
}
case KW_LEFT:
{
l = LT(1);
l_AST = (Aast)astFactory.create(l);
match(KW_LEFT);
hide(l);
{
switch ( LA(1)) {
case KW_OUTER:
{
out = LT(1);
out_AST = (Aast)astFactory.create(out);
match(KW_OUTER);
hide(out);
break;
}
case KW_JOIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_JOIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
j = LT(1);
j_AST = (Aast)astFactory.create(j);
astFactory.makeASTRoot(currentAST, j_AST);
match(KW_JOIN);
j_AST.setType(l_AST == null ? INNER_JOIN : LEFT_OUTER_JOIN);
sql_table_spec();
astFactory.addASTChild(currentAST, returnAST);
sql_join_condition();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt629>=1 ) { break _loop629; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt629++;
} while (true);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
sql_explicit_join_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_168);
}
returnAST = sql_explicit_join_AST;
}
/**
* Matches an <code>ON</code> followed by an {@link #expr} which is a SQL
* join condition. Separated to build the tree properly.
*/
public final void sql_join_condition() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_join_condition_AST = null;
try { // for error handling
Aast tmp943_AST = null;
tmp943_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp943_AST);
match(KW_ON);
expr();
astFactory.addASTChild(currentAST, returnAST);
sql_join_condition_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_176);
}
returnAST = sql_join_condition_AST;
}
/**
* Matches a correlation name ({@link #symbol}) in an {@link #sql_table_spec}
* and creates a new buffer for the given table name.
*
* @param rtext
* The table which is getting an alias.
*/
public final void sql_correlation_name(
String rtext
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_correlation_name_AST = null;
Aast c_AST = null;
try { // for error handling
symbol();
c_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
defineBufferFromSymbol(c_AST, rtext, null, null, false);
sql_correlation_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_175);
}
returnAST = sql_correlation_name_AST;
}
/**
* Matches the indicator variable specification in a {@link #sql_into}.
* Uses {@link #lvalue}.
*/
public final void sql_indicator_var() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_indicator_var_AST = null;
try { // for error handling
Aast tmp944_AST = null;
tmp944_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp944_AST);
match(KW_INDICAT);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
sql_indicator_var_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_177);
}
returnAST = sql_indicator_var_AST;
}
/**
* Match the <code>ASCEND</code> or <code>DESCEND</code> keywords. Called
* by {@link #sql_order_by}.
*/
public final void sql_direction_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sql_direction_spec_AST = null;
Token a = null;
Aast a_AST = null;
try { // for error handling
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);
sql_direction_spec_AST = (Aast)currentAST.root;
break;
}
case KW_DESCEND:
{
Aast tmp945_AST = null;
tmp945_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp945_AST);
match(KW_DESCEND);
sql_direction_spec_AST = (Aast)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = sql_direction_spec_AST;
}
/**
* Matches the <code>RECID or ROWID</code> keywords and the following
* expression inside parenthesis. Calls {@link #expr} and is called by
* {@link #create_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void recid_or_rowid() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast recid_or_rowid_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_RECID:
{
Aast tmp946_AST = null;
tmp946_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp946_AST);
match(KW_RECID);
break;
}
case KW_ROWID:
{
Aast tmp947_AST = null;
tmp947_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp947_AST);
match(KW_ROWID);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
recid_or_rowid_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_91);
}
returnAST = recid_or_rowid_AST;
}
/**
* Matches all language statements that have assignment-like syntax. The
* following statements are so simple that they don't have separate rules
* but are instead treated as global variables that always exist (thus they
* are not referenced here but are directly matched in the calling rule):
* <p>
* <pre>
* CURRENT-LANGUAGE
* FRAME-VALUE
* PROMSGS
* PROPATH
* </pre>
* <p>
* These statements are referenced:
* <p>
* <ul>
* <li> {@link #current_value_stmt}
* <li> {@link #dynamic_current_value_stmt}
* <li> {@link #dynamic_new_stmt}
* <li> {@link #dynamic_prop_stmt}
* <li> {@link #fix_codepage_stmt}
* <li> {@link #overlay_stmt}
* <li> {@link #set_byte_order_stmt}
* <li> {@link #set_pointer_value_stmt}
* <li> {@link #set_size_stmt}
* </ul>
* The following statements will be parsed as a function call and will be fixed after, in
* {@link #restoreAssignStyleStmt}, and they are commented in this rule:
* <ul>
* <li> {@link #entry_stmt}
* <li> {@link #extent_stmt}
* <li> {@link #length_stmt}
* <li> {@link #raw_stmt}
* <li> {@link #substring_stmt}
* </ul>
* <p>
* This rule is consolidated to allow these constructs to be accessed from
* {@link #lvalue} which allows then to be in an {@link #assign_stmt} which
* actually calls this rule via {@link #assign}. Top level use of these as
* a language statement is handled via the {@link #assignment} rule which
* also handles the matching for the <code>EQUALS</code> and following
* {@link #expr}.
*/
public final void assign_type_syntax_stmt_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assign_type_syntax_stmt_list_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_CUR_VAL:
{
current_value_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DYN_CURV:
{
dynamic_current_value_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DYN_NEW:
{
dynamic_new_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DYN_PROP:
{
dynamic_prop_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FIX_CP:
{
fix_codepage_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OVERLAY:
{
overlay_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_PUT_BYTE:
case KW_PUT_BITS:
case KW_PUT_BYTS:
case KW_PUT_I64:
case KW_PUT_DBL:
case KW_PUT_FLT:
case KW_PUT_LONG:
case KW_PUT_SHT:
case KW_PUT_STR:
case KW_PUT_UL:
case KW_PUT_USHT:
{
put_memptr_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SET_B_OR:
{
set_byte_order_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SET_PTR:
{
set_pointer_value_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SET_SZ:
{
set_size_stmt();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
assign_type_syntax_stmt_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = assign_type_syntax_stmt_list_AST;
}
/**
* Matches the <code>CURRENT-VALUE</code> language statement. Calls
* {@link #sequence_ref} and {@link #database_name} rules.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
*/
public final void current_value_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast current_value_stmt_AST = null;
Token d = null;
Aast d_AST = null;
try { // for error handling
Aast tmp948_AST = null;
tmp948_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp948_AST);
match(KW_CUR_VAL);
lparens();
astFactory.addASTChild(currentAST, returnAST);
sequence_ref();
astFactory.addASTChild(currentAST, returnAST);
if (LA(2) != DATABASE)
{
int newtype = sym.lookupDatabase(LT(2).getText());
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if (newtype != -1)
{
LT(2).setType(newtype);
}
}
{
if ((LA(1)==COMMA) && (LA(2)==DATABASE||LA(2)==STRING) && (LA(3)==COMMA||LA(3)==RPARENS)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case DATABASE:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.addASTChild(currentAST, d_AST);
match(DATABASE);
saveAndReplaceTypeAndText(d_AST, STRING, "\"" + d_AST.getText() + "\"");
break;
}
case STRING:
{
Aast tmp949_AST = null;
tmp949_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp949_AST);
match(STRING);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==COMMA||LA(1)==RPARENS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
current_value_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = current_value_stmt_AST;
}
/**
* Matches the <code>DYNAMIC-CURRENT-VALUE</code> language statement. Calls
* {@link #database_name} rules.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
*/
public final void dynamic_current_value_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_current_value_stmt_AST = null;
try { // for error handling
Aast tmp950_AST = null;
tmp950_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp950_AST);
match(KW_DYN_CURV);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
dynamic_current_value_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = dynamic_current_value_stmt_AST;
}
/**
* Matches the <code>DYNAMIC-NEW</code> statement which looks like an
* assignment, allowing new object instances to be instantiated using a
* runtime (dynamic) choice of the class. Uses {@link #func_call_parameters}
* and is called from {@link #assign_type_syntax_stmt_list} which means
* that the leftmost <code>lvalue EQUALS</code> is factored out.
*/
public final void dynamic_new_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_new_stmt_AST = null;
try { // for error handling
Aast tmp951_AST = null;
tmp951_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp951_AST);
match(KW_DYN_NEW);
sym.setLocalLookup(true);
expr();
astFactory.addASTChild(currentAST, returnAST);
sym.setLocalLookup(false);
func_call_parameters(false);
astFactory.addASTChild(currentAST, returnAST);
dynamic_new_stmt_AST = (Aast)currentAST.root;
// save the original token type, then rewrite the type
dynamic_new_stmt_AST.putAnnotation("oldtype", Long.valueOf(dynamic_new_stmt_AST.getType()));
dynamic_new_stmt_AST.setType(FUNC_CLASS);
// write our function-specific annotations
sym.annotateFunction(dynamic_new_stmt_AST.getText(), dynamic_new_stmt_AST, false);
// the above probably did not set the class name so we force it here
sym.annotateClassRef("Progress.Lang.Object", dynamic_new_stmt_AST);
dynamic_new_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = dynamic_new_stmt_AST;
}
/**
* Matches the <code>ENTRY</code> language statement. Calls {@link #expr} rule for up to 3 parameters.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
*/
public final void dynamic_prop_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_prop_stmt_AST = null;
try { // for error handling
Aast tmp952_AST = null;
tmp952_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp952_AST);
match(KW_DYN_PROP);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
dynamic_prop_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = dynamic_prop_stmt_AST;
}
/**
* Matches the <code>FIX-CODEPAGE</code> language statement. Calls the
* {@link #expr} rule.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
*/
public final void fix_codepage_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast fix_codepage_stmt_AST = null;
try { // for error handling
Aast tmp953_AST = null;
tmp953_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp953_AST);
match(KW_FIX_CP);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
fix_codepage_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = fix_codepage_stmt_AST;
}
/**
* Matches the <code>OVERLAY</code> language statement. Calls {@link #expr},
* and {@link #lvalue} rules.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
*/
public final void overlay_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast overlay_stmt_AST = null;
try { // for error handling
Aast tmp954_AST = null;
tmp954_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp954_AST);
match(KW_OVERLAY);
lparens();
astFactory.addASTChild(currentAST, returnAST);
chained_object_members();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
overlay_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = overlay_stmt_AST;
}
/**
* Matches the <code>SUBSTRING( , , , ) = expression</code> language
* statement. This rule uses a rule reference to process expressions
* for what appear to be comma-separated parameters (see {@link #expr}).
* Some tokens are suppressed and the <code>EQUALS</code> token is processed
* in the calling rule. The resulting AST should be easy to process.
* <p>
* This language statement has inherent ambiguity with the built-in function
* that uses the same <code>SUBSTRING</code> keyword (and has a nearly
* identical meaning but is only for use in expressions and it cannot be used
* as an assignment). Progress gives precedence to matching the language
* statement first and then the function form. This parser implements this
* rule in the {@link #lvalue} portion of the top-level {@link #assignment}
* rule. Since this is matched before expressions (which is where a function
* call is matched) the logic works properly and all ambiguity is resolved.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
* The call is commented because the this statement is processed via the func_call, and after that fixed in
* restoreAssignStyleStmt.
*/
public final void substring_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast substring_stmt_AST = null;
try { // for error handling
Aast tmp955_AST = null;
tmp955_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp955_AST);
match(KW_SUBSTR);
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
substring_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = substring_stmt_AST;
}
/**
* Simple rule to handle the common case where a {@link #filename}, a
* <code>STRING</code> or a {@link #value} can be matched.
* <p>
* Called by {@link #compile_stmt}, {@link #into_directory_clause},
* {@link #save_cache_stmt} and {@link #io_through_stmt}.
*/
public final void external_name_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast external_name_spec_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
{
if ((LA(1)==STRING) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.addASTChild(currentAST, s_AST);
match(STRING);
convertStringTo(s_AST, FILENAME);
}
else if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
filename(null);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
external_name_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_28);
}
returnAST = external_name_spec_AST;
}
/**
* Matches the core set of options for the compile statement.
* <p>
* Calls:
* <p>
* <ul>
* <li> {@link #embedded_assign}
* <li> {@link #into_directory_clause}
* <li> {@link #external_name_spec}
* <li> {@link #optional_listing_clause}
* <li> {@link #expr}
* <li> {@link #languages_clause}
* </ul>
* <p>
* Used by {@link #compile_stmt}.
*/
public final void compile_options_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast compile_options_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_ATTR:
case KW_STRM_IO:
case KW_GEN_MD5:
case KW_MIN_SZ:
{
{
switch ( LA(1)) {
case KW_ATTR:
{
Aast tmp956_AST = null;
tmp956_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp956_AST);
match(KW_ATTR);
break;
}
case KW_STRM_IO:
{
Aast tmp957_AST = null;
tmp957_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp957_AST);
match(KW_STRM_IO);
break;
}
case KW_MIN_SZ:
{
Aast tmp958_AST = null;
tmp958_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp958_AST);
match(KW_MIN_SZ);
break;
}
case KW_GEN_MD5:
{
Aast tmp959_AST = null;
tmp959_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp959_AST);
match(KW_GEN_MD5);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case EQUALS:
{
embedded_assign();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_NO_ATTR:
{
Aast tmp960_AST = null;
tmp960_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp960_AST);
match(KW_NO_ATTR);
break;
}
case KW_OPTIONS:
{
Aast tmp961_AST = null;
tmp961_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp961_AST);
match(KW_OPTIONS);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_OPTIONSF:
{
Aast tmp962_AST = null;
tmp962_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp962_AST);
match(KW_OPTIONSF);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_SAVE:
{
Aast tmp963_AST = null;
tmp963_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp963_AST);
match(KW_SAVE);
{
switch ( LA(1)) {
case EQUALS:
{
embedded_assign();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_INTO:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_INTO:
{
into_directory_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_LISTING:
{
Aast tmp964_AST = null;
tmp964_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp964_AST);
match(KW_LISTING);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
{
_loop689:
do {
if ((LA(1)==KW_APPEND||LA(1)==KW_PAGE_SZ||LA(1)==KW_PAGE_WID)) {
optional_listing_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop689;
}
} while (true);
}
break;
}
case KW_XCODE:
{
Aast tmp965_AST = null;
tmp965_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp965_AST);
match(KW_XCODE);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_XREF:
case KW_STR_XREF:
{
{
switch ( LA(1)) {
case KW_STR_XREF:
{
Aast tmp966_AST = null;
tmp966_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp966_AST);
match(KW_STR_XREF);
break;
}
case KW_XREF:
{
Aast tmp967_AST = null;
tmp967_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp967_AST);
match(KW_XREF);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_APPEND:
case KW_PAGE_SZ:
case KW_PAGE_WID:
{
optional_listing_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_XREF_XML:
{
Aast tmp968_AST = null;
tmp968_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp968_AST);
match(KW_XREF_XML);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LANGUAGE:
{
languages_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_DBG_LST:
case KW_PREPROC:
{
{
switch ( LA(1)) {
case KW_DBG_LST:
{
Aast tmp969_AST = null;
tmp969_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp969_AST);
match(KW_DBG_LST);
break;
}
case KW_PREPROC:
{
Aast tmp970_AST = null;
tmp970_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp970_AST);
match(KW_PREPROC);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_NO_ERROR:
{
Aast tmp971_AST = null;
tmp971_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp971_AST);
match(KW_NO_ERROR);
break;
}
case KW_V6FRAME:
{
Aast tmp972_AST = null;
tmp972_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp972_AST);
match(KW_V6FRAME);
{
switch ( LA(1)) {
case EQUALS:
{
embedded_assign();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
case KW_USE_REV:
case KW_USE_UND:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_USE_REV:
{
Aast tmp973_AST = null;
tmp973_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp973_AST);
match(KW_USE_REV);
break;
}
case KW_USE_UND:
{
Aast tmp974_AST = null;
tmp974_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp974_AST);
match(KW_USE_UND);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
compile_options_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_178);
}
returnAST = compile_options_clause_AST;
}
/**
* Matches the <code>INTO</code> keyword followed by a directory name.
* <p>
* Calls {@link #external_name_spec}.
* <p>
* Used by {@link #compile_options_clause}.
*/
public final void into_directory_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast into_directory_clause_AST = null;
try { // for error handling
Aast tmp975_AST = null;
tmp975_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp975_AST);
match(KW_INTO);
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
into_directory_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_178);
}
returnAST = into_directory_clause_AST;
}
/**
* Matches the <code>APPEND, PAGE-SIZE and PAGE-WIDTH</code> keywords
* followed by an {@link #embedded_assign} or an {@link #expr}.
* <p>
* Used by {@link #compile_options_clause}.
*/
public final void optional_listing_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast optional_listing_clause_AST = null;
try { // for error handling
switch ( LA(1)) {
case KW_APPEND:
{
Aast tmp976_AST = null;
tmp976_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp976_AST);
match(KW_APPEND);
{
switch ( LA(1)) {
case EQUALS:
{
embedded_assign();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_APPEND:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_PAGE_SZ:
case KW_PAGE_WID:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
optional_listing_clause_AST = (Aast)currentAST.root;
break;
}
case KW_PAGE_SZ:
{
Aast tmp977_AST = null;
tmp977_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp977_AST);
match(KW_PAGE_SZ);
expr();
astFactory.addASTChild(currentAST, returnAST);
optional_listing_clause_AST = (Aast)currentAST.root;
break;
}
case KW_PAGE_WID:
{
Aast tmp978_AST = null;
tmp978_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp978_AST);
match(KW_PAGE_WID);
expr();
astFactory.addASTChild(currentAST, returnAST);
optional_listing_clause_AST = (Aast)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_179);
}
returnAST = optional_listing_clause_AST;
}
/**
* Matches the <code>LANGUAGES</code> keyword and a parenthesized,
* comma-separated list of {@link #language_list} entries. This can be
* followed by an {@link #embedded_assign} option.
* <p>
* Used by {@link #compile_options_clause}.
*/
public final void languages_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast languages_clause_AST = null;
try { // for error handling
Aast tmp979_AST = null;
tmp979_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp979_AST);
match(KW_LANGUAGE);
lparens();
astFactory.addASTChild(currentAST, returnAST);
language_list();
astFactory.addASTChild(currentAST, returnAST);
{
_loop700:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
language_list();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop700;
}
} while (true);
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TXT_SEG:
{
Aast tmp980_AST = null;
tmp980_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp980_AST);
match(KW_TXT_SEG);
embedded_assign();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ATTR:
case KW_DBG_LST:
case KW_LISTING:
case KW_NO_ATTR:
case KW_NO_ERROR:
case KW_PREPROC:
case KW_SAVE:
case KW_STRM_IO:
case KW_V6FRAME:
case KW_XCODE:
case KW_XREF:
case KW_XREF_XML:
case KW_GEN_MD5:
case KW_LANGUAGE:
case KW_MIN_SZ:
case KW_OPTIONS:
case KW_OPTIONSF:
case KW_STR_XREF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
languages_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_178);
}
returnAST = languages_clause_AST;
}
/**
* Matches the a list of colon separated languages, all of which are made
* children of an artificial mode of type <code>LANGUAGES</code>. Each
* language is matched by a {@link #expr}.
* <p>
* Used by {@link #languages_clause}.
*/
public final void language_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast language_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(LANGUAGES,"language list"));
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop704:
do {
if ((LA(1)==COLON)) {
colon();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop704;
}
} while (true);
}
language_list_AST = (Aast)currentAST.root;
if (language_list_AST.getNumberOfChildren() == 0) language_list_AST = null;
currentAST.root = language_list_AST;
currentAST.child = language_list_AST!=null &&language_list_AST.getFirstChild()!=null ?
language_list_AST.getFirstChild() : language_list_AST;
currentAST.advanceChildToEnd();
language_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_29);
}
returnAST = language_list_AST;
}
/**
* Matches the widget phrase construct of the Progress 4GL language which
* consists of the optional <code>FIELD</code> keyword prefix and the
* required following widget reference. This optionally appears in a
* referencing rule but does not begin with a specific keyword. All real
* processing is done using the {@link #widget} rule which really delegates
* its work to {@link #lvalue}.
* <p>
* The <code>INPUT</code> keyword can be optionally inserted between the
* <code>TO</code> and the widget. This is undocumented and has no discernable
* semantic meaning so it is dropped from the tree. If the <code>INPUT</code>
* keyword does exist, then it can be followed by an optional
* {@link #frame_reference} which can't normally exist in front of the
* widget.
* <p>
* Called from {@link #hide_stmt}, {@link #view_stmt}, {@link #widget_list}
* {@link #comma_widget_list} and {@link #focus_clause}.
*/
public final void widget_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast widget_phrase_AST = null;
Token fi = null;
Aast fi_AST = null;
Token in = null;
Aast in_AST = null;
try { // for error handling
{
if ((LA(1)==KW_FIELD)) {
fi = LT(1);
fi_AST = (Aast)astFactory.create(fi);
match(KW_FIELD);
hide(fi);
}
else if ((_tokenSet_150.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_INPUT)) {
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INPUT);
hide(in);
{
if ((LA(1)==KW_FRAME) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
frame_reference(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((_tokenSet_64.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
widget();
astFactory.addASTChild(currentAST, returnAST);
widget_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_141);
}
returnAST = widget_phrase_AST;
}
/**
* Matches the <code>MESSAGE STRING or NO-MESSAGE</code> clause used in the
* <code>PAUSE</code> language statement. Called by {@link #pause_stmt}.
*/
public final void simple_message_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_message_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_MSG:
{
Aast tmp981_AST = null;
tmp981_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp981_AST);
match(KW_MSG);
Aast tmp982_AST = null;
tmp982_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp982_AST);
match(STRING);
break;
}
case KW_NO_MSG:
{
Aast tmp983_AST = null;
tmp983_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp983_AST);
match(KW_NO_MSG);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
simple_message_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_135);
}
returnAST = simple_message_clause_AST;
}
/**
* Matches the <code>ALL</code> keyword and an optional list of fields
* that should not be included. Calls the {@link #widget_array} rule.
* <p>
* Used by {@link #disable_stmt} and {@link #enable_stmt}.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void all_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast all_clause_AST = null;
try { // for error handling
Aast tmp984_AST = null;
tmp984_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp984_AST);
match(KW_ALL);
{
switch ( LA(1)) {
case KW_EXCEPT:
{
Aast tmp985_AST = null;
tmp985_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp985_AST);
match(KW_EXCEPT);
widget_array();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_WITH:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
all_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_180);
}
returnAST = all_clause_AST;
}
/**
* Matches a field name and an optional <code>WHEN</code> condition.
* Calls the {@link #widget} and {@link #format_phrase} rules.
* <p>
* Used by {@link #disable_stmt}, {@link #enable_stmt} and
* {@link #text_clause}.
* <p>
* The use of the format phrase naturally conflicts with the large set of
* possible following tokens. This is not really ambiguous so warnings
* have been disabled.
* <p>
* This is a separate rule to centralize logic.
*
* @param enableWidget
* <code>true</code> if this field clause represents a widget being enabled in a frame;
* else <code>false</code>.
*/
public final void field_clause(
boolean enableWidget
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast field_clause_AST = null;
Aast l_AST = null;
Aast f_AST = null;
try { // for error handling
Aast fld = null;
String symbolName = null;
{
allowSymbolMatch = true;
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// reset each loop iteration
symbolName = null;
fld = null;
if (l_AST.getType() == SYMBOL)
{
symbolName = l_AST.getText();
}
else
{
fld = findFieldNode(l_AST);
}
allowSymbolMatch = false;
{
if ((_tokenSet_181.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_phrase(symbolName, fld, true, enableWidget);
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_182.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
field_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_182);
}
returnAST = field_clause_AST;
}
/**
* Matches the optional <code>PAUSE</code> keyword prefix and the required
* following numeric {@link #expr}.
* <p>
* Used by {@link #readkey_stmt} and {@link #wait_for_stmt} rules.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void pause_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast pause_clause_AST = null;
try { // for error handling
Aast tmp986_AST = null;
tmp986_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp986_AST);
match(KW_PAUSE);
expr();
astFactory.addASTChild(currentAST, returnAST);
pause_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_140);
}
returnAST = pause_clause_AST;
}
/**
* Matches the <code>DELIMITER</code> keyword and the following single
* quoted character (a <code>STRING</code>).
* <p>
* Used by {@link #export_stmt} and {@link #import_stmt} rules.
*/
public final void delimiter_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast delimiter_clause_AST = null;
try { // for error handling
Aast tmp987_AST = null;
tmp987_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp987_AST);
match(KW_DELIMIT);
Aast tmp988_AST = null;
tmp988_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp988_AST);
match(STRING);
delimiter_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_84);
}
returnAST = delimiter_clause_AST;
}
/**
* Implements proper tree building for the most common field specification
* in the {@link #export_stmt}. Roots an {@link #expr} at a node of type
* <code>EXPORT_FIELD</code>.
* <p>
* Progress has an undocumented feature where format and aggregate phrases
* can be attached to any expression but although a {@link #format_phrase}
* and {@link #aggregate_phrase} are matched, they are dropped from the
* resulting tree since in Progress they are silently ignored.
*/
public final void export_field() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast export_field_AST = null;
Aast ag_AST = null;
Aast fmt_AST = null;
try { // for error handling
int numFP = 0;
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(EXPORT_FIELD,"output field"));
{
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop763:
do {
if ((LA(1)==LPARENS) && (_tokenSet_75.member(LA(2))) && (_tokenSet_183.member(LA(3)))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
aggregate_phrase();
ag_AST = (Aast)returnAST;
hide(ag_AST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_184.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( numFP < 2 )) {
format_phrase(null, null, false, false);
fmt_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
numFP++;
}
else {
break _loop763;
}
} while (true);
}
}
export_field_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_21);
}
returnAST = export_field_AST;
}
/**
* Matches the <code>UNFORMATTED</code> keyword and the following {@link #record} or
* {@link #lvalue}. The record case is an undocumented feature of the 4GL.
* <p>
* Another undocumented feature (found in customer source code) is that a CARET can be inserted
* before the <code>lvalue</code>. It generates a warning message but still runs un the 4GL.
* The meaning is questionable (it is probably ignored) since the idea is to read the entire
* line into the lvalue and the caret means "ignore the content in this position", but in
* "whole line" more it doesn't make sense.
* <p>
* Used by {@link #import_stmt}.
*/
public final void unformatted_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast unformatted_clause_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp989_AST = null;
tmp989_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp989_AST);
match(KW_UNFORMAT);
{
if (((_tokenSet_13.member(LA(1))) && (LA(2)==DOT||LA(2)==KW_NO_ERROR||LA(2)==KW_NO_LOBS) && (_tokenSet_11.member(LA(3))))&&( isRecord(LT(1).getText()) )) {
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_185.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
{
int _cnt778=0;
_loop778:
do {
if ((LA(1)==CARET)) {
Aast tmp990_AST = null;
tmp990_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp990_AST);
match(CARET);
}
else if ((_tokenSet_64.member(LA(1)))) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt778>=1 ) { break _loop778; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt778++;
} while (true);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
unformatted_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_186);
}
returnAST = unformatted_clause_AST;
}
/**
* Implements proper tree building for the most common field specification
* in the {@link #import_stmt}. Roots an {@link #lvalue} at a node of type
* <code>IMPORT_FIELD</code>.
*/
public final void import_field() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast import_field_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(IMPORT_FIELD,"input field"));
{
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
import_field_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_129);
}
returnAST = import_field_AST;
}
/**
* Matches the optional prefix <code>BUFFER or FIELD</code> keyword and
* the required following buffer ({@link #record}) or field {@link #lvalue}.
* These two alternatives are disambiguated by semantic predicate.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Used by {@link #raw_transfer_stmt}.
*/
public final void buffer_or_field_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast buffer_or_field_spec_AST = null;
Token bu = null;
Aast bu_AST = null;
Token fi = null;
Aast fi_AST = null;
try { // for error handling
NameNode nothing = null;
{
if ((LA(1)==KW_BUFFER) && (_tokenSet_49.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
bu = LT(1);
bu_AST = (Aast)astFactory.create(bu);
match(KW_BUFFER);
hide(bu);
}
else if ((LA(1)==KW_FIELD)) {
fi = LT(1);
fi_AST = (Aast)astFactory.create(fi);
match(KW_FIELD);
hide(fi);
}
else if ((_tokenSet_49.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_13.member(LA(1))) && (LA(2)==DOT||LA(2)==KW_NO_ERROR||LA(2)==KW_TO) && (_tokenSet_11.member(LA(3))))&&( isRecord(LT(1).getText()) )) {
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
buffer_or_field_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_187);
}
returnAST = buffer_or_field_spec_AST;
}
/**
* Match the <code>FROM</code> specification of {@link #copy_lob_stmt} using
* {@link #lob_spec}, {@link #starting_clause} and {@link #for_clause}. The
* result is always rooted at a <code>KW_FROM</code>, even though that keyword
* is optional in the 4GL (a token will be manufactured if needed).
*/
public final void from_lob_source() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast from_lob_source_AST = null;
try { // for error handling
if (LA(1) != KW_FROM)
{
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(KW_FROM,"from"));
}
{
if ((LA(1)==KW_FROM) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp991_AST = null;
tmp991_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp991_AST);
match(KW_FROM);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lob_spec(false);
astFactory.addASTChild(currentAST, returnAST);
{
_loop791:
do {
switch ( LA(1)) {
case KW_STARTING:
{
starting_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FOR:
{
for_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
break _loop791;
}
}
} while (true);
}
from_lob_source_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_188);
}
returnAST = from_lob_source_AST;
}
/**
* Match the <code>TO</code> specification of {@link #copy_lob_stmt} using
* {@link #lob_spec}. The result is always rooted at a <code>KW_TO</code>.
*/
public final void to_lob_target() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast to_lob_target_AST = null;
try { // for error handling
Aast tmp992_AST = null;
tmp992_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp992_AST);
match(KW_TO);
lob_spec(true);
astFactory.addASTChild(currentAST, returnAST);
to_lob_target_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_189);
}
returnAST = to_lob_target_AST;
}
/**
* Match the <code>NO-CONVERT</code> or a <code>CONVERT</code> followed by
* two {@link #source_or_target_clause} references. Called by
* {@link #io_options} and {@link #copy_lob_stmt}.
*/
public final void codepage_convert_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast codepage_convert_phrase_AST = null;
try { // for error handling
switch ( LA(1)) {
case KW_NO_CVT:
{
Aast tmp993_AST = null;
tmp993_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp993_AST);
match(KW_NO_CVT);
codepage_convert_phrase_AST = (Aast)currentAST.root;
break;
}
case KW_CONVERT:
{
Aast tmp994_AST = null;
tmp994_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp994_AST);
match(KW_CONVERT);
{
_loop1005:
do {
if ((LA(1)==KW_SOURCE||LA(1)==KW_TARGET)) {
source_or_target_clause(true);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1005;
}
} while (true);
}
codepage_convert_phrase_AST = (Aast)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = codepage_convert_phrase_AST;
}
/**
* Match the specification of a single source or target LOB with is either an {@link #expr}
* (optionally prepended with the <code>KW_OBJECT</code>) or a <code>KW_FILE</code> followed by
* an {@link #expr}. If <code>to</code> is <code>true</code> then {@link #overlay_clause} or
* <code>KW_APPEND</code> can be optionally matched at the end. Used by {@link #from_lob_source}
* and {@link #to_lob_target}.
*/
public final void lob_spec(
boolean to
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast lob_spec_AST = null;
Token ob = null;
Aast ob_AST = null;
try { // for error handling
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_FILE )) {
{
if ((LA(1)==KW_OBJECT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
ob = LT(1);
ob_AST = (Aast)astFactory.create(ob);
match(KW_OBJECT);
hide(ob);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_OVERLAY))&&( to )) {
overlay_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_191.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((LA(1)==KW_FILE) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp995_AST = null;
tmp995_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp995_AST);
match(KW_FILE);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_APPEND))&&( to )) {
Aast tmp996_AST = null;
tmp996_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp996_AST);
match(KW_APPEND);
}
else if ((_tokenSet_191.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lob_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_191);
}
returnAST = lob_spec_AST;
}
/**
* Matches the <code>STARTING</code> keyword followed by <code>AT</code>
* (which is dropped from the tree) and an {@link #expr}. Used by
* {@link #from_lob_source}.
*/
public final void starting_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast starting_clause_AST = null;
Token at = null;
Aast at_AST = null;
try { // for error handling
Aast tmp997_AST = null;
tmp997_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp997_AST);
match(KW_STARTING);
at = LT(1);
at_AST = (Aast)astFactory.create(at);
match(KW_AT);
hide(at);
expr();
astFactory.addASTChild(currentAST, returnAST);
starting_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_192);
}
returnAST = starting_clause_AST;
}
/**
* Matches the <code>FOR</code> keyword followed by an {@link #expr}. Used by
* {@link #from_lob_source}.
*/
public final void for_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_clause_AST = null;
try { // for error handling
Aast tmp998_AST = null;
tmp998_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp998_AST);
match(KW_FOR);
expr();
astFactory.addASTChild(currentAST, returnAST);
for_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_192);
}
returnAST = for_clause_AST;
}
/**
* Matches the <code>OVERLAY</code> keyword followed by <code>AT</code>
* (which is dropped from the tree) and an {@link #expr}. <code>KW_TRIM</code>
* is optionally matched at the end. Used by {@link #lob_spec}.
*/
public final void overlay_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast overlay_clause_AST = null;
Token at = null;
Aast at_AST = null;
try { // for error handling
Aast tmp999_AST = null;
tmp999_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp999_AST);
match(KW_OVERLAY);
at = LT(1);
at_AST = (Aast)astFactory.create(at);
match(KW_AT);
hide(at);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_TRIM:
{
Aast tmp1000_AST = null;
tmp1000_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1000_AST);
match(KW_TRIM);
break;
}
case DOT:
case KW_FOR:
case KW_NO_ERROR:
case KW_TO:
case KW_CONVERT:
case KW_NO_CVT:
case KW_STARTING:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
overlay_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_191);
}
returnAST = overlay_clause_AST;
}
/**
* Matches the <code>ENTRY</code> language statement. Calls {@link #expr},
* and {@link #lvalue} rules.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
* The call is commented because the this statement is processed via the func_call, and after that fixed in
* restoreAssignStyleStmt.
*/
public final void entry_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast entry_stmt_AST = null;
try { // for error handling
Aast tmp1001_AST = null;
tmp1001_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1001_AST);
match(KW_ENTRY);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
entry_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = entry_stmt_AST;
}
/**
* Matches the <code>EXTENT</code> language statement. Calls {@link #lvalue}.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
* The call is commented because the this statement is processed via the func_call, and after that fixed in
* restoreAssignStyleStmt.
*/
public final void extent_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast extent_stmt_AST = null;
try { // for error handling
Aast tmp1002_AST = null;
tmp1002_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1002_AST);
match(KW_EXTENT);
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
extent_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = extent_stmt_AST;
}
/**
* Matches the <code>LENGTH</code> language statement. Calls {@link #lvalue}.
* <p>
* It turns out is NOT an Oracle-only statement, contrary to the
* documentation.
* <p>
* Used by {@link #assign_type_syntax_stmt_list}.
* The call is commented because the this statement is processed via the func_call, and after that fixed in
* restoreAssignStyleStmt.
*/
public final void length_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast length_stmt_AST = null;
try { // for error handling
Aast tmp1003_AST = null;
tmp1003_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1003_AST);
match(KW_LENGTH);
lparens();
astFactory.addASTChild(currentAST, returnAST);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
length_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = length_stmt_AST;
}
/**
* Sequence references are unquoted text that must match a sequence name
* defined in an accessible schema. This rule matches a {@link #symbol} and
* converts that token into a properly formatted <code>STRING</code>.
*/
public final void sequence_ref() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sequence_ref_AST = null;
Aast s_AST = null;
try { // for error handling
symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// convert unquoted sequence name to a quoted string
saveAndReplaceTypeAndText(s_AST, STRING, "\"" + s_AST.getText() + "\"");
sequence_ref_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_29);
}
returnAST = sequence_ref_AST;
}
/**
* Matches the {@code current-value}, {@code dynamic-current-value}, {@code dynamic-next-value}
* and {@code next-value()} function calls. The root node returned will be a {@code FUNC_INT} or a
* {@code FUNC_INT64} and there will be 1 to 3 children, of which the first two are {@code STRING}
* nodes but the last is an {@code FUNC_INT} representing the optional {@code tenant-id} target.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter is created as a separate child
* node of the function type token. All parameters are maintained as child
* nodes in the exact order of the function call itself, so this is
* essentially the signature of the function. It it also the proper AST
* definition to enable simple evaluation of functions with any arbitrary
* signature.
*/
public final void sequence_funcs() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sequence_funcs_AST = null;
Token d = null;
Aast d_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_CUR_VAL:
{
Aast tmp1004_AST = null;
tmp1004_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1004_AST);
match(KW_CUR_VAL);
break;
}
case KW_NEXT_VAL:
{
Aast tmp1005_AST = null;
tmp1005_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1005_AST);
match(KW_NEXT_VAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
sequence_ref();
astFactory.addASTChild(currentAST, returnAST);
if (LA(2) != DATABASE)
{
int newtype = sym.lookupDatabase(LT(2).getText());
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if (newtype != -1)
{
LT(2).setType(newtype);
}
}
{
if ((LA(1)==COMMA) && (LA(2)==DATABASE||LA(2)==STRING) && (LA(3)==COMMA||LA(3)==RPARENS)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case DATABASE:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.addASTChild(currentAST, d_AST);
match(DATABASE);
saveAndReplaceTypeAndText(d_AST, STRING, "\"" + d_AST.getText() + "\"");
break;
}
case STRING:
{
Aast tmp1006_AST = null;
tmp1006_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1006_AST);
match(STRING);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==COMMA||LA(1)==RPARENS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
sequence_funcs_AST = (Aast)currentAST.root;
// save the original token type, then rewrite the type
saveAndReplaceType(sequence_funcs_AST, FUNC_INT64);
// write our function-specific annotations
sym.annotateFunction(sequence_funcs_AST.getText(), sequence_funcs_AST, false);
sequence_funcs_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = sequence_funcs_AST;
}
/**
* Aggregates (in a tree building sense) a simple list of all fields under a specific language
* statement. Calls {@link #lvalue} and roots everything at a node of type
* <code>CONTENT_ARRAY</code>. An undocumented feature of Progress is that each lvalue can
* optionally be followed by a format phrase (using the {@link #format_phrase} rule).
*
* @param fields
* Set into which all database field references should be stored.
*/
public final void lvalue_list(
Set<Aast> fields
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast lvalue_list_AST = null;
Aast l_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(CONTENT_ARRAY,""));
{
int _cnt841=0;
_loop841:
do {
if ((_tokenSet_64.member(LA(1)))) {
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_98.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_phrase(null, null, false, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_97.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
int type = l_AST.getType();
if (type > BEGIN_FIELDTYPES && type < END_FIELDTYPES)
{
fields.add(l_AST);
}
}
else {
if ( _cnt841>=1 ) { break _loop841; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt841++;
} while (true);
}
lvalue_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_99);
}
returnAST = lvalue_list_AST;
}
/**
* Matches a greatly simplified form of the <code>ON</code> statement which
* is only seen in a {@link #trigger_phrase} Progress construct. See
* {@link #on_stmt} for details on the more complicated form. This form
* is not compatible with the language statement itself which is why
* this is a separate rule. This separation also allows the AST to be
* built in a more natural manner.
* <p>
* This is the location in which we add and remove scopes to the symbol
* dictionary for trigger blocks.
* <p>
* Bogus ANTLR ambiguity warnings have been suppressed.
*/
public final void simple_on_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_on_stmt_AST = null;
try { // for error handling
boolean oldBufScope = setupTriggerScope();
Aast tmp1007_AST = null;
tmp1007_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1007_AST);
match(KW_ON);
fixupKeyboardModifiers();
comma_event_list();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_ANYWHERE) && (_tokenSet_10.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1008_AST = null;
tmp1008_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1008_AST);
match(KW_ANYWHERE);
}
else if ((_tokenSet_10.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_PERSIST) && (LA(2)==KW_RUN) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
persistent_trigger_procedure();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_10.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
single_block(true, true);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
clearTriggerScope(oldBufScope);
simple_on_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_193);
}
returnAST = simple_on_stmt_AST;
}
/**
* Matches a comma delimited list of events. Calls {@link #event}.
* <p>
* Used by ON.
* <p>
* <b>This rule uses a trick to create an artificial node as a root while
* still allowing ANTLR to do normal tree building (no suppression of the
* AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used
* such that the contents of the loop cannot be referenced in a manually
* built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4) the
* ability to label a loop such that the entire contents can be referenced.
* If one labels the individual elements inside the loop, only the last one
* is available when the loop concludes. However, by leaving the normal
* tree creation unchanged but manually creating an artificial node and
* manually setting this node as the root of the returned tree BEFORE the
* children are added, this problem can be solved.
*/
public final void comma_event_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast comma_event_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(EVENT_LIST,""));
event();
astFactory.addASTChild(currentAST, returnAST);
{
_loop932:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
fixupKeyboardModifiers();
event();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop932;
}
} while (true);
}
comma_event_list_AST = (Aast)currentAST.root;
if (comma_event_list_AST.getNumberOfChildren() == 0) comma_event_list_AST = null;
currentAST.root = comma_event_list_AST;
currentAST.child = comma_event_list_AST!=null &&comma_event_list_AST.getFirstChild()!=null ?
comma_event_list_AST.getFirstChild() : comma_event_list_AST;
currentAST.advanceChildToEnd();
comma_event_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_10);
}
returnAST = comma_event_list_AST;
}
/**
* Matches the <code>PERSISTENT</code> keyword and the following subset of
* the {@link #run_stmt}. This matches more constructs than a normal
* persistent trigger could specify but this should not matter in valid
* Progress code.
* <p>
* Used by {@link #on_stmt}.
*/
public final void persistent_trigger_procedure() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast persistent_trigger_procedure_AST = null;
try { // for error handling
Aast tmp1009_AST = null;
tmp1009_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1009_AST);
match(KW_PERSIST);
run_stmt();
astFactory.addASTChild(currentAST, returnAST);
persistent_trigger_procedure_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = persistent_trigger_procedure_AST;
}
/**
* Implements the referencing phrase to modify a database event trigger,
* matches on the <code>NEW or OLD</code> keywords and all following
* optional or required constructs.
* <p>
* The 4GL documentation incorrectly specifies that for <code>WRITE</code>
* triggers, there will be both a <code>NEW</code> and <code>OLD</code>
* keyword, but it turns out that the <code>NEW</code> keyword is optional,
* so the <code>OLD</code> keyword can appear by itself.
* <p>
* This is separated to make the AST build more natural. Note that this
* AST could be improved further.
*
* @param ref
* The record or field being referenced.
*/
public final void write_referencing_phrase(
Aast ref
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast write_referencing_phrase_AST = null;
Token bu = null;
Aast bu_AST = null;
Aast b_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_NEW:
{
Aast tmp1010_AST = null;
tmp1010_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1010_AST);
match(KW_NEW);
break;
}
case KW_OLD:
{
Aast tmp1011_AST = null;
tmp1011_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1011_AST);
match(KW_OLD);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_BUFFER) && (_tokenSet_15.member(LA(2))) && (_tokenSet_11.member(LA(3)))) {
bu = LT(1);
bu_AST = (Aast)astFactory.create(bu);
match(KW_BUFFER);
hide(bu);
}
else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
symbol();
b_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
write_referencing_phrase_AST = (Aast)currentAST.root;
write_referencing_phrase_AST.putAnnotation("define_buffer", Boolean.valueOf(true));
defineBufferFromSymbol(b_AST, ref.getText(), null, null, false);
write_referencing_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = write_referencing_phrase_AST;
}
/**
* Handles parsing of the NEW VALUE from the ASSIGN schema trigger procedure. The VALUE
* token is optional and is dropped anyway.
*
* Called by {@link #trigger_procedure_stmt}.
*/
public final void assign_trigger_new_var_def() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assign_trigger_new_var_def_AST = null;
Token va = null;
Aast va_AST = null;
Aast sy_AST = null;
try { // for error handling
String symname = null;
Aast tmp1012_AST = null;
tmp1012_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1012_AST);
match(KW_NEW);
{
if ((LA(1)==KW_VALUE)) {
va = LT(1);
va_AST = (Aast)astFactory.create(va);
match(KW_VALUE);
hide(va);
}
else if ((_tokenSet_15.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
symname=regular_parm(null, null);
sy_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
assign_trigger_new_var_def_AST = (Aast)currentAST.root;
sym.setVariableOptions(sy_AST.getText(), assign_trigger_new_var_def_AST);
sym.annotateVariableOptions(sy_AST.getText(), assign_trigger_new_var_def_AST, true);
assign_trigger_new_var_def_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = assign_trigger_new_var_def_AST;
}
/**
* Process the OLD variable definition option for an assignment trigger procedure.
* <p>
* Matches only <code>OLD</code> branch followed by an optional <code>VALUE</code> keyword
* (dropped) and then the variable definition which is handled by {@link #regular_parm}.
* <p>
* If the <code>likeRef</code> parameter is non-null AND this is a keyword <code>OLD</code>
* where there is no explicit <code>AS</code> or <code>LIKE</code>, then this code will
* implement an implicit <code>LIKE</code> clause. This is an undocumented feature that
* was found in customer code.
* <p>
* Called by {@link #trigger_procedure_stmt}, {@link #on_stmt}.
*
* @param likeRef
* The variable or field definition to use for an implicit LIKE clause. This may be
* <code>null</code>.
*/
public final void assign_trigger_old_var_def(
Aast likeRef
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assign_trigger_old_var_def_AST = null;
Token va = null;
Aast va_AST = null;
try { // for error handling
String symname = null;
{
if ((LA(1)==KW_OLD) && (_tokenSet_194.member(LA(2))) && (_tokenSet_93.member(LA(3)))) {
Aast tmp1013_AST = null;
tmp1013_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1013_AST);
match(KW_OLD);
{
if ((LA(1)==KW_VALUE)) {
va = LT(1);
va_AST = (Aast)astFactory.create(va);
match(KW_VALUE);
hide(va);
}
else if ((_tokenSet_15.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
symname=regular_parm(null, likeRef);
astFactory.addASTChild(currentAST, returnAST);
assign_trigger_old_var_def_AST = (Aast)currentAST.root;
// ##.putAnnotation("define_buffer", Boolean.valueOf(false));
// pass the AST with all options to the symbol resolver to set
// those variable options accordingly
sym.setVariableOptions(symname, assign_trigger_old_var_def_AST);
// write any non-standard options into annotations
sym.annotateVariableOptions(symname, assign_trigger_old_var_def_AST, true);
}
else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
assign_trigger_old_var_def_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = assign_trigger_old_var_def_AST;
}
/**
* Matches any valid Progress symbol or string returns an artificial token
* <code>DB_EVENT</code> with a child that is the matched token. Matches
* <code>CREATE, DELETE, FIND, WRITE and ASSIGN</code> keywords.
* <p>
* Used by {@link #on_stmt}.
*/
public final void db_event() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast db_event_AST = null;
Token c = null;
Aast c_AST = null;
Token d = null;
Aast d_AST = null;
Token f = null;
Aast f_AST = null;
Token w = null;
Aast w_AST = null;
Token a = null;
Aast a_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_CREATE:
{
c = LT(1);
c_AST = (Aast)astFactory.create(c);
match(KW_CREATE);
break;
}
case KW_DELETE:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
match(KW_DELETE);
break;
}
case KW_FIND:
{
f = LT(1);
f_AST = (Aast)astFactory.create(f);
match(KW_FIND);
break;
}
case KW_WRITE:
{
w = LT(1);
w_AST = (Aast)astFactory.create(w);
match(KW_WRITE);
break;
}
case KW_ASSIGN:
{
a = LT(1);
a_AST = (Aast)astFactory.create(a);
match(KW_ASSIGN);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
db_event_AST = (Aast)currentAST.root;
db_event_AST = (Aast)astFactory.make( (new ASTArray(6)).add((Aast)astFactory.create(DB_EVENT,"database event")).add(c_AST).add(d_AST).add(f_AST).add(w_AST).add(a_AST));
currentAST.root = db_event_AST;
currentAST.child = db_event_AST!=null &&db_event_AST.getFirstChild()!=null ?
db_event_AST.getFirstChild() : db_event_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_195);
}
returnAST = db_event_AST;
}
/**
* Matches any valid Progress symbol or string or other key label and returns
* an artificial token <code>EVENT</code> with a child that is the matched
* token. Calls {@link #symbol} and {@link #other_single_char_tokens}.
* <p>
* Used by {@link #event_list} and {@link #comma_event_list}.
*/
public final void event() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast event_AST = null;
Token s = null;
Aast s_AST = null;
Aast o_AST = null;
Aast e_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case STRING:
{
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.addASTChild(currentAST, s_AST);
match(STRING);
break;
}
case MINUS:
case PLUS:
case UNKNOWN_TOKEN:
case AT:
case EQUALS:
case LBRACKET:
case RBRACKET:
case LPARENS:
case RPARENS:
case MULTIPLY:
case CARET:
case GT:
case LT:
case DIVIDE:
case UNKNOWN_VAL:
case NUM_LITERAL:
{
other_single_char_tokens();
o_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
if ((_tokenSet_27.member(LA(1)))) {
reserved_or_symbol();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
event_AST = (Aast)currentAST.root;
if (s_AST != null) convertStringTo(s_AST, EVENT);
if (o_AST != null) o_AST.setType(EVENT);
if (e_AST != null) e_AST.setType(EVENT);
// verify if the event is registered in FWD, accross all keyboards
if (!com.goldencode.p2j.ui.Keyboard.registeredEventName(event_AST.getText()))
{
LOG.log(Level.SEVERE, "Event [" + event_AST.getText() + "] is not registered in FWD!");
}
event_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_109);
}
returnAST = event_AST;
}
/**
* Matches the list of all valid key function names and generates a node
* of type <code>KEY_FUNCTION</code>. Used by {@link #on_stmt}.
* <p>
* <pre>
* ABORT
* APPEND-LINE (undocumented)
* BACKSPACE
* BACK-TAB
* BELL
* CLEAR
* CURSOR-DOWN
* CURSOR-LEFT
* CURSOR-RIGHT
* CURSOR-UP
* DELETE-CHARACTER
* DELETE-LINE (undocumented)
* EDITOR-TAB (undocumented)
* END
* END-ERROR
* ENDKEY
* ENTER-MENUBAR
* ERROR
* GET (undocumented)
* GO
* HELP
* HOME
* INSERT-MODE
* LEFT-END
* NEW-LINE (undocumented)
* NEXT-FRAME
* PREV-FRAME
* RECALL
* RETURN
* RIGHT-END
* SCROLL-MODE
* STOP
* TAB
* </pre>
* <p>
* <b>Page 785 of the Progress Language Reference lists these as the only
* valid key functions that can be assigned actions.</b> This is the same
* as the list on page 6-26 in the Progress Programming Handbook, which
* makes the same statement about this being the list of possible actions.
* However, page 6-19 in the Progress Programming Handbook, has a much
* longer list of key functions and tests show that these other functions
* ARE accepted in such an <code>ON</code> statement. These confusingly
* documented additional keywords are supported here. Working 4GL code does
* rely upon these events. The keywords that are added (the other keywords
* show up in both lists) are:
* <p>
* <pre>
* BLOCK
* BOTTOM-COLUMN
* BREAK-LINE
* CANCEL-PICK
* CHOICES
* CLOSE
* COMPILE
* COPY
* CUT
* DEFAULT-POP-UP
* DELETE-COLUMN
* DELETE-END-LINE
* DELETE-FIELD
* DOWN (found in customer source, not in documentation)
* EDITOR-BACKTAB
* EXIT
* FIND
* FIND-NEXT
* FIND-PREVIOUS
* GOTO
* INSERT-COLUMN
* INSERT-FIELD
* INSERT-FIELD-DATA
* INSERT-FIELD-LABEL
* LEFT (found in customer source, not in documentation)
* MAIN-MENU
* MOVE
* NEW
* NEXT-ERROR
* NEXT-WORD
* OPEN-LINE-ABOVE
* OPTIONS
* PAGE-DOWN
* PAGE-LEFT
* PAGE-RIGHT
* PAGE-UP
* PASTE
* PICK
* PICK-AREA
* PICK-BOTH
* PREV-WORD
* PUT
* REPLACE
* REPORTS
* RESUME-DISPLAY
* RIGHT (found in customer source, not in documentation)
* SAVE-AS
* SCROLL-LEFT
* SCROLL-RIGHT
* SETTINGS
* STOP-DISPLAY
* TOP-COLUMN
* UNIX-END
* UP (found in customer source, not in documentation)
* </pre>
*/
public final void key_function() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast key_function_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case STRING:
{
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.addASTChild(currentAST, s_AST);
match(STRING);
break;
}
case KW_ABORT:
{
Aast tmp1014_AST = null;
tmp1014_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1014_AST);
match(KW_ABORT);
break;
}
case KW_APPEND_L:
{
Aast tmp1015_AST = null;
tmp1015_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1015_AST);
match(KW_APPEND_L);
break;
}
case KW_BACKSP:
{
Aast tmp1016_AST = null;
tmp1016_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1016_AST);
match(KW_BACKSP);
break;
}
case KW_BACK_TAB:
{
Aast tmp1017_AST = null;
tmp1017_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1017_AST);
match(KW_BACK_TAB);
break;
}
case KW_BELL:
{
Aast tmp1018_AST = null;
tmp1018_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1018_AST);
match(KW_BELL);
break;
}
case KW_CLEAR:
{
Aast tmp1019_AST = null;
tmp1019_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1019_AST);
match(KW_CLEAR);
break;
}
case KW_CUR_DOWN:
{
Aast tmp1020_AST = null;
tmp1020_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1020_AST);
match(KW_CUR_DOWN);
break;
}
case KW_CUR_LEFT:
{
Aast tmp1021_AST = null;
tmp1021_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1021_AST);
match(KW_CUR_LEFT);
break;
}
case KW_CUR_RGHT:
{
Aast tmp1022_AST = null;
tmp1022_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1022_AST);
match(KW_CUR_RGHT);
break;
}
case KW_CUR_UP:
{
Aast tmp1023_AST = null;
tmp1023_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1023_AST);
match(KW_CUR_UP);
break;
}
case KW_DEL_CHAR:
{
Aast tmp1024_AST = null;
tmp1024_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1024_AST);
match(KW_DEL_CHAR);
break;
}
case KW_DEL_LINE:
{
Aast tmp1025_AST = null;
tmp1025_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1025_AST);
match(KW_DEL_LINE);
break;
}
case KW_EDIT_TAB:
{
Aast tmp1026_AST = null;
tmp1026_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1026_AST);
match(KW_EDIT_TAB);
break;
}
case KW_END:
{
Aast tmp1027_AST = null;
tmp1027_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1027_AST);
match(KW_END);
break;
}
case KW_END_ERR:
{
Aast tmp1028_AST = null;
tmp1028_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1028_AST);
match(KW_END_ERR);
break;
}
case KW_ENDKEY:
{
Aast tmp1029_AST = null;
tmp1029_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1029_AST);
match(KW_ENDKEY);
break;
}
case KW_ENTER_MB:
{
Aast tmp1030_AST = null;
tmp1030_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1030_AST);
match(KW_ENTER_MB);
break;
}
case KW_ERROR:
{
Aast tmp1031_AST = null;
tmp1031_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1031_AST);
match(KW_ERROR);
break;
}
case KW_GET:
{
Aast tmp1032_AST = null;
tmp1032_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1032_AST);
match(KW_GET);
break;
}
case KW_GO:
{
Aast tmp1033_AST = null;
tmp1033_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1033_AST);
match(KW_GO);
break;
}
case KW_HELP:
{
Aast tmp1034_AST = null;
tmp1034_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1034_AST);
match(KW_HELP);
break;
}
case KW_HOME:
{
Aast tmp1035_AST = null;
tmp1035_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1035_AST);
match(KW_HOME);
break;
}
case KW_INS_MODE:
{
Aast tmp1036_AST = null;
tmp1036_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1036_AST);
match(KW_INS_MODE);
break;
}
case KW_LEFT_END:
{
Aast tmp1037_AST = null;
tmp1037_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1037_AST);
match(KW_LEFT_END);
break;
}
case KW_NEW_LINE:
{
Aast tmp1038_AST = null;
tmp1038_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1038_AST);
match(KW_NEW_LINE);
break;
}
case KW_NEXT_FR:
{
Aast tmp1039_AST = null;
tmp1039_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1039_AST);
match(KW_NEXT_FR);
break;
}
case KW_PREV_FR:
{
Aast tmp1040_AST = null;
tmp1040_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1040_AST);
match(KW_PREV_FR);
break;
}
case KW_RECALL:
{
Aast tmp1041_AST = null;
tmp1041_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1041_AST);
match(KW_RECALL);
break;
}
case KW_RETURN:
{
Aast tmp1042_AST = null;
tmp1042_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1042_AST);
match(KW_RETURN);
break;
}
case KW_RT_END:
{
Aast tmp1043_AST = null;
tmp1043_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1043_AST);
match(KW_RT_END);
break;
}
case KW_SCR_MODE:
{
Aast tmp1044_AST = null;
tmp1044_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1044_AST);
match(KW_SCR_MODE);
break;
}
case KW_STOP:
{
Aast tmp1045_AST = null;
tmp1045_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1045_AST);
match(KW_STOP);
break;
}
case KW_TAB:
{
Aast tmp1046_AST = null;
tmp1046_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1046_AST);
match(KW_TAB);
break;
}
case KW_BLOCK:
{
Aast tmp1047_AST = null;
tmp1047_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1047_AST);
match(KW_BLOCK);
break;
}
case KW_BOTTOM_C:
{
Aast tmp1048_AST = null;
tmp1048_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1048_AST);
match(KW_BOTTOM_C);
break;
}
case KW_BREAK_L:
{
Aast tmp1049_AST = null;
tmp1049_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1049_AST);
match(KW_BREAK_L);
break;
}
case KW_CANCEL_P:
{
Aast tmp1050_AST = null;
tmp1050_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1050_AST);
match(KW_CANCEL_P);
break;
}
case KW_CHOICES:
{
Aast tmp1051_AST = null;
tmp1051_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1051_AST);
match(KW_CHOICES);
break;
}
case KW_CLOSE:
{
Aast tmp1052_AST = null;
tmp1052_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1052_AST);
match(KW_CLOSE);
break;
}
case KW_COMPILE:
{
Aast tmp1053_AST = null;
tmp1053_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1053_AST);
match(KW_COMPILE);
break;
}
case KW_COPY:
{
Aast tmp1054_AST = null;
tmp1054_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1054_AST);
match(KW_COPY);
break;
}
case KW_CUT:
{
Aast tmp1055_AST = null;
tmp1055_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1055_AST);
match(KW_CUT);
break;
}
case KW_DEF_POP:
{
Aast tmp1056_AST = null;
tmp1056_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1056_AST);
match(KW_DEF_POP);
break;
}
case KW_DEL_COL:
{
Aast tmp1057_AST = null;
tmp1057_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1057_AST);
match(KW_DEL_COL);
break;
}
case KW_DEL_E_L:
{
Aast tmp1058_AST = null;
tmp1058_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1058_AST);
match(KW_DEL_E_L);
break;
}
case KW_DEL_FLD:
{
Aast tmp1059_AST = null;
tmp1059_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1059_AST);
match(KW_DEL_FLD);
break;
}
case KW_DEL_WORD:
{
Aast tmp1060_AST = null;
tmp1060_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1060_AST);
match(KW_DEL_WORD);
break;
}
case KW_EDIT_B_T:
{
Aast tmp1061_AST = null;
tmp1061_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1061_AST);
match(KW_EDIT_B_T);
break;
}
case KW_EXIT:
{
Aast tmp1062_AST = null;
tmp1062_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1062_AST);
match(KW_EXIT);
break;
}
case KW_FIND:
{
Aast tmp1063_AST = null;
tmp1063_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1063_AST);
match(KW_FIND);
break;
}
case KW_FIND_NXT:
{
Aast tmp1064_AST = null;
tmp1064_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1064_AST);
match(KW_FIND_NXT);
break;
}
case KW_FIND_PRV:
{
Aast tmp1065_AST = null;
tmp1065_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1065_AST);
match(KW_FIND_PRV);
break;
}
case KW_GOTO:
{
Aast tmp1066_AST = null;
tmp1066_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1066_AST);
match(KW_GOTO);
break;
}
case KW_INS_COL:
{
Aast tmp1067_AST = null;
tmp1067_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1067_AST);
match(KW_INS_COL);
break;
}
case KW_INS_FLD:
{
Aast tmp1068_AST = null;
tmp1068_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1068_AST);
match(KW_INS_FLD);
break;
}
case KW_INS_FLDD:
{
Aast tmp1069_AST = null;
tmp1069_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1069_AST);
match(KW_INS_FLDD);
break;
}
case KW_INS_FLDL:
{
Aast tmp1070_AST = null;
tmp1070_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1070_AST);
match(KW_INS_FLDL);
break;
}
case KW_MAINMENU:
{
Aast tmp1071_AST = null;
tmp1071_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1071_AST);
match(KW_MAINMENU);
break;
}
case KW_MOVE:
{
Aast tmp1072_AST = null;
tmp1072_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1072_AST);
match(KW_MOVE);
break;
}
case KW_NEW:
{
Aast tmp1073_AST = null;
tmp1073_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1073_AST);
match(KW_NEW);
break;
}
case KW_NEXT_ERR:
{
Aast tmp1074_AST = null;
tmp1074_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1074_AST);
match(KW_NEXT_ERR);
break;
}
case KW_NEXTWORD:
{
Aast tmp1075_AST = null;
tmp1075_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1075_AST);
match(KW_NEXTWORD);
break;
}
case KW_OPEN_L_A:
{
Aast tmp1076_AST = null;
tmp1076_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1076_AST);
match(KW_OPEN_L_A);
break;
}
case KW_OPTIONS:
{
Aast tmp1077_AST = null;
tmp1077_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1077_AST);
match(KW_OPTIONS);
break;
}
case KW_PAGE_DWN:
{
Aast tmp1078_AST = null;
tmp1078_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1078_AST);
match(KW_PAGE_DWN);
break;
}
case KW_PAGE_LFT:
{
Aast tmp1079_AST = null;
tmp1079_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1079_AST);
match(KW_PAGE_LFT);
break;
}
case KW_PAGE_RT:
{
Aast tmp1080_AST = null;
tmp1080_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1080_AST);
match(KW_PAGE_RT);
break;
}
case KW_PAGE_UP:
{
Aast tmp1081_AST = null;
tmp1081_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1081_AST);
match(KW_PAGE_UP);
break;
}
case KW_PASTE:
{
Aast tmp1082_AST = null;
tmp1082_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1082_AST);
match(KW_PASTE);
break;
}
case KW_PICK:
{
Aast tmp1083_AST = null;
tmp1083_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1083_AST);
match(KW_PICK);
break;
}
case KW_PICK_ARE:
{
Aast tmp1084_AST = null;
tmp1084_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1084_AST);
match(KW_PICK_ARE);
break;
}
case KW_PICK_BTH:
{
Aast tmp1085_AST = null;
tmp1085_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1085_AST);
match(KW_PICK_BTH);
break;
}
case KW_PREVWORD:
{
Aast tmp1086_AST = null;
tmp1086_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1086_AST);
match(KW_PREVWORD);
break;
}
case KW_PUT:
{
Aast tmp1087_AST = null;
tmp1087_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1087_AST);
match(KW_PUT);
break;
}
case KW_REPLACE:
{
Aast tmp1088_AST = null;
tmp1088_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1088_AST);
match(KW_REPLACE);
break;
}
case KW_REPORTS:
{
Aast tmp1089_AST = null;
tmp1089_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1089_AST);
match(KW_REPORTS);
break;
}
case KW_RESUME_D:
{
Aast tmp1090_AST = null;
tmp1090_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1090_AST);
match(KW_RESUME_D);
break;
}
case KW_SAVE_AS:
{
Aast tmp1091_AST = null;
tmp1091_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1091_AST);
match(KW_SAVE_AS);
break;
}
case KW_SCR_LEFT:
{
Aast tmp1092_AST = null;
tmp1092_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1092_AST);
match(KW_SCR_LEFT);
break;
}
case KW_SCR_RT:
{
Aast tmp1093_AST = null;
tmp1093_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1093_AST);
match(KW_SCR_RT);
break;
}
case KW_SETTINGS:
{
Aast tmp1094_AST = null;
tmp1094_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1094_AST);
match(KW_SETTINGS);
break;
}
case KW_STOP_D:
{
Aast tmp1095_AST = null;
tmp1095_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1095_AST);
match(KW_STOP_D);
break;
}
case KW_TOP_COL:
{
Aast tmp1096_AST = null;
tmp1096_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1096_AST);
match(KW_TOP_COL);
break;
}
case KW_UNIX_END:
{
Aast tmp1097_AST = null;
tmp1097_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1097_AST);
match(KW_UNIX_END);
break;
}
case KW_DOWN:
{
Aast tmp1098_AST = null;
tmp1098_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1098_AST);
match(KW_DOWN);
break;
}
case KW_LEFT:
{
Aast tmp1099_AST = null;
tmp1099_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1099_AST);
match(KW_LEFT);
break;
}
case KW_RIGHT:
{
Aast tmp1100_AST = null;
tmp1100_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1100_AST);
match(KW_RIGHT);
break;
}
case KW_UP:
{
Aast tmp1101_AST = null;
tmp1101_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1101_AST);
match(KW_UP);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
key_function_AST = (Aast)currentAST.root;
// convert the string to a keyword (TODO: this does not check for the matching subset
// of key function types)
if (s_AST != null)
{
convertStringTo(s_AST, -1);
}
saveAndReplaceType(key_function_AST, KEY_FUNCTION);
key_function_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = key_function_AST;
}
/**
* Matches a comma delimited list of widgets. Calls {@link #widget_phrase}.
* <p>
* Used by ON.
* <p>
* <b>This rule uses a trick to create an artificial node as a root while
* still allowing ANTLR to do normal tree building (no suppression of the
* AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used
* such that the contents of the loop cannot be referenced in a manually
* built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4) the
* ability to label a loop such that the entire contents can be referenced.
* If one labels the individual elements inside the loop, only the last one
* is available when the loop concludes. However, by leaving the normal
* tree creation unchanged but manually creating an artificial node and
* manually setting this node as the root of the returned tree BEFORE the
* children are added, this problem can be solved.
*/
public final void comma_widget_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast comma_widget_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(WIDGET_LIST,""));
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
{
_loop925:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop925;
}
} while (true);
}
comma_widget_list_AST = (Aast)currentAST.root;
if (comma_widget_list_AST.getNumberOfChildren() == 0) comma_widget_list_AST = null;
currentAST.root = comma_widget_list_AST;
currentAST.child = comma_widget_list_AST!=null &&comma_widget_list_AST.getFirstChild()!=null ?
comma_widget_list_AST.getFirstChild() : comma_widget_list_AST;
currentAST.advanceChildToEnd();
comma_widget_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = comma_widget_list_AST;
}
/**
* Matches the <code>OR</code> keyword, the required comma separated event
* list, <code>OF</code> keyword and then a widget list. Calls
* {@link #comma_event_list} and {@link #comma_widget_list} rules.
* <p>
* Used by {@link #on_stmt}.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void comma_events_of_widgets_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast comma_events_of_widgets_clause_AST = null;
Token or = null;
Aast or_AST = null;
try { // for error handling
or = LT(1);
or_AST = (Aast)astFactory.create(or);
match(KW_OR);
hide(or); fixupKeyboardModifiers();
comma_event_list();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp1102_AST = null;
tmp1102_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1102_AST);
match(KW_OF);
comma_widget_list();
astFactory.addASTChild(currentAST, returnAST);
comma_events_of_widgets_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = comma_events_of_widgets_clause_AST;
}
/**
* Match an end statement (and following DOT) that does not have an associated opening block.
* This will manufacture an empty block to be returned, so that the downstream code can treat
* this normally.
*/
public final void end_stmt_with_no_beginning() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast end_stmt_with_no_beginning_AST = null;
try { // for error handling
end_stmt(true);
end_stmt_with_no_beginning_AST = (Aast)currentAST.root;
// build the tree
end_stmt_with_no_beginning_AST = (Aast)astFactory.make( (new ASTArray(3)).add((Aast)astFactory.create(TRIGGER_BLOCK,"trigger block")).add((Aast)astFactory.create(KW_DO,"do")).add((Aast)astFactory.create(BLOCK,"block")));
currentAST.root = end_stmt_with_no_beginning_AST;
currentAST.child = end_stmt_with_no_beginning_AST!=null &&end_stmt_with_no_beginning_AST.getFirstChild()!=null ?
end_stmt_with_no_beginning_AST.getFirstChild() : end_stmt_with_no_beginning_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_11);
}
returnAST = end_stmt_with_no_beginning_AST;
}
/**
* Matches the <code>TO widget_phrase</code> construct of the
* {@link #apply_stmt}. Separated to improve the tree build.
*/
public final void to_event_target() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast to_event_target_AST = null;
try { // for error handling
Aast tmp1103_AST = null;
tmp1103_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1103_AST);
match(KW_TO);
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
to_event_target_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = to_event_target_AST;
}
/**
* Matches the <code>FOCUS</code> keyword and the required following
* widget. Calls {@link #widget_phrase}.
* <p>
* Used by {@link #wait_for_stmt}.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void focus_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast focus_clause_AST = null;
try { // for error handling
Aast tmp1104_AST = null;
tmp1104_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1104_AST);
match(KW_FOCUS);
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
focus_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_140);
}
returnAST = focus_clause_AST;
}
/**
* Matches the optional <code>OR</code> keyword prefix and the required
* event list, <code>OF</code> keyword and then a widget list. Calls
* {@link #event_list} and {@link #widget_list} rules.
* <p>
* Used by {@link #wait_for_stmt}.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*/
public final void events_of_widgets_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast events_of_widgets_clause_AST = null;
Token or = null;
Aast or_AST = null;
try { // for error handling
{
if ((LA(1)==KW_OR) && (_tokenSet_108.member(LA(2))) && (_tokenSet_142.member(LA(3)))) {
or = LT(1);
or_AST = (Aast)astFactory.create(or);
match(KW_OR);
hide(or);
}
else if ((_tokenSet_108.member(LA(1))) && (_tokenSet_142.member(LA(2))) && (_tokenSet_143.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
event_list();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp1105_AST = null;
tmp1105_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1105_AST);
match(KW_OF);
widget_list();
astFactory.addASTChild(currentAST, returnAST);
events_of_widgets_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_140);
}
returnAST = events_of_widgets_clause_AST;
}
/**
* Matches the <code>SET handle</code> clause and a following {@link #lvalue}.
* <p>
* Used by {@link #wait_for_dotnet_stmt}. The subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void set_lvalue() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_lvalue_AST = null;
try { // for error handling
Aast tmp1106_AST = null;
tmp1106_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1106_AST);
match(KW_SET);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
set_lvalue_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = set_lvalue_AST;
}
/**
* Matches a space or comma delimited list of events. Calls {@link #event}.
* <p>
* Used by {@link #wait_for_stmt}.
* <p>
* <b>This rule uses a trick to create an artificial node as a root while
* still allowing ANTLR to do normal tree building (no suppression of the
* AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used
* such that the contents of the loop cannot be referenced in a manually
* built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4) the
* ability to label a loop such that the entire contents can be referenced.
* If one labels the individual elements inside the loop, only the last one
* is available when the loop concludes. However, by leaving the normal
* tree creation unchanged but manually creating an artificial node and
* manually setting this node as the root of the returned tree BEFORE the
* children are added, this problem can be solved.
* <p>
* This construct is dangerous because the loop must be manually closed.
* The core issue is that an event can match a reserved keyword and thus
* even the <code>OF</code> keyword will be matched as an event rather than
* the keyword that denotes the end of the event list. This is only a
* problem because of the optional commas that delimit events. If the comma
* was mandatory, then the lack of a following comma would end the list
* as is the case in {@link #comma_event_list}. A semantic predicate was
* added to close the loop manually when the <code>OF</code> keyword is
* encountered.
*/
public final void event_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast event_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(EVENT_LIST,""));
event();
astFactory.addASTChild(currentAST, returnAST);
{
_loop929:
do {
if (((_tokenSet_142.member(LA(1))) && (_tokenSet_142.member(LA(2))) && (_tokenSet_143.member(LA(3))))&&( LA(1) != KW_OF )) {
{
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_108.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
event();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop929;
}
} while (true);
}
event_list_AST = (Aast)currentAST.root;
if (event_list_AST.getNumberOfChildren() == 0) event_list_AST = null;
currentAST.root = event_list_AST;
currentAST.child = event_list_AST!=null &&event_list_AST.getFirstChild()!=null ?
event_list_AST.getFirstChild() : event_list_AST;
currentAST.advanceChildToEnd();
event_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_195);
}
returnAST = event_list_AST;
}
/**
* Matches a space or comma delimited list of widgets. Calls
* {@link #widget_phrase}.
* <p>
* Used by {@link #wait_for_stmt} and this form has <code>WAIT-FOR</code>
* specific logic so it may not be suitable for other use.
* <p>
* Bogus ANTLR ambiguity warnings have been suppressed.
* <p>
* <b>This rule uses a trick to create an artificial node as a root while
* still allowing ANTLR to do normal tree building (no suppression of the
* AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used
* such that the contents of the loop cannot be referenced in a manually
* built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4) the
* ability to label a loop such that the entire contents can be referenced.
* If one labels the individual elements inside the loop, only the last one
* is available when the loop concludes. However, by leaving the normal
* tree creation unchanged but manually creating an artificial node and
* manually setting this node as the root of the returned tree BEFORE the
* children are added, this problem can be solved.
* <p>
* This construct is dangerous because the loop must be manually closed.
* The core issue is that a widget phrase can match a the <code>FOCUS</code>
* system handle BUT <code>WAIT-FOR</code> also uses the <code>KW_FOCUS</code>
* for its own purposes. This means that the second and following widget
* phrases must not match a <code>FOCUS</code> system handle but instead must
* manually close the loop and allow the calling code to match with a
* {@link #focus_clause}. This is only a problem because of the optional
* commas that delimit widgets. If the comma was mandatory, then the lack of
* a following comma would end the list as is the case in
* {@link #comma_widget_list}. A semantic predicate was added to close the
* loop manually when a <code>KW_FOCUS</code> is encountered.
*/
public final void widget_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast widget_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(WIDGET_LIST,""));
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
{
_loop921:
do {
if (((_tokenSet_196.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_FOCUS )) {
{
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_124.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop921;
}
} while (true);
}
widget_list_AST = (Aast)currentAST.root;
if (widget_list_AST.getNumberOfChildren() == 0) widget_list_AST = null;
currentAST.root = widget_list_AST;
currentAST.child = widget_list_AST!=null &&widget_list_AST.getFirstChild()!=null ?
widget_list_AST.getFirstChild() : widget_list_AST;
currentAST.advanceChildToEnd();
widget_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_140);
}
returnAST = widget_list_AST;
}
/**
* Matches a single widget and wrapps in a root node of type WIDGET_LIST. Calls
* {@link #widget_phrase}.
*/
public final void single_widget_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast single_widget_list_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(WIDGET_LIST,""));
widget_phrase();
astFactory.addASTChild(currentAST, returnAST);
single_widget_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_140);
}
returnAST = single_widget_list_AST;
}
/**
* Matches any valid Progress single char key label that would not be
* recognized as a symbol or string. Note that
* <code>DOT, COLON and COMMA</code> are left out to allow parsing to
* properly occur. It is probable that to use these as key labels in
* Progress, one would have to put the character in a string.
* <p>
* Matches:
* <p>
* <pre>
* EQUALS
* GT
* LT
* LPARENS
* RPARENS
* LBRACKET
* RBRACKET
* PLUS
* MINUS
* MULTIPLY
* DIVIDE
* AT
* CARET
* UNKNOWN_VAL
* NUM_LITERAL
* UNKNOWN_TOKEN
* </pre>
* <p>
* Called by {@link #event}. <b>USE THIS SPARINGLY, IT IS NASTY!</b>
*/
public final void other_single_char_tokens() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast other_single_char_tokens_AST = null;
try { // for error handling
switch ( LA(1)) {
case EQUALS:
{
Aast tmp1107_AST = null;
tmp1107_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1107_AST);
match(EQUALS);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case GT:
{
Aast tmp1108_AST = null;
tmp1108_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1108_AST);
match(GT);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case LT:
{
Aast tmp1109_AST = null;
tmp1109_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1109_AST);
match(LT);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case LPARENS:
{
Aast tmp1110_AST = null;
tmp1110_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1110_AST);
match(LPARENS);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case RPARENS:
{
Aast tmp1111_AST = null;
tmp1111_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1111_AST);
match(RPARENS);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case LBRACKET:
{
Aast tmp1112_AST = null;
tmp1112_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1112_AST);
match(LBRACKET);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case RBRACKET:
{
Aast tmp1113_AST = null;
tmp1113_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1113_AST);
match(RBRACKET);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case PLUS:
{
Aast tmp1114_AST = null;
tmp1114_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1114_AST);
match(PLUS);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case MINUS:
{
Aast tmp1115_AST = null;
tmp1115_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1115_AST);
match(MINUS);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case MULTIPLY:
{
Aast tmp1116_AST = null;
tmp1116_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1116_AST);
match(MULTIPLY);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case DIVIDE:
{
Aast tmp1117_AST = null;
tmp1117_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1117_AST);
match(DIVIDE);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case AT:
{
Aast tmp1118_AST = null;
tmp1118_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1118_AST);
match(AT);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case CARET:
{
Aast tmp1119_AST = null;
tmp1119_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1119_AST);
match(CARET);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case UNKNOWN_VAL:
{
Aast tmp1120_AST = null;
tmp1120_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1120_AST);
match(UNKNOWN_VAL);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case NUM_LITERAL:
{
Aast tmp1121_AST = null;
tmp1121_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1121_AST);
match(NUM_LITERAL);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
case UNKNOWN_TOKEN:
{
Aast tmp1122_AST = null;
tmp1122_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1122_AST);
match(UNKNOWN_TOKEN);
other_single_char_tokens_AST = (Aast)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_109);
}
returnAST = other_single_char_tokens_AST;
}
/**
* Aggregates (in a tree building sense) a simple list of all fields under a specific language
* statement. Calls {@link #widget} and roots everything at a node of type
* <code>CONTENT_ARRAY</code>. The widget array can be empty (undocumented feature).
*/
public final void widget_array() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast widget_array_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(CONTENT_ARRAY,""));
{
_loop942:
do {
if ((_tokenSet_64.member(LA(1)))) {
widget();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop942;
}
} while (true);
}
widget_array_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_180);
}
returnAST = widget_array_AST;
}
/**
* Matches the <code>DIR</code> keyword and a following {@link #expr}.
* <p>
* Used by {@link #load_stmt}.
*/
public final void dir_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dir_clause_AST = null;
try { // for error handling
Aast tmp1123_AST = null;
tmp1123_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1123_AST);
match(KW_DIR);
expr();
astFactory.addASTChild(currentAST, returnAST);
dir_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_197);
}
returnAST = dir_clause_AST;
}
/**
* Matches the <code>BASE-KEY</code> keyword and a following
* {@link #external_name_spec}.
* <p>
* Used by {@link #load_stmt}.
*/
public final void base_key_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast base_key_clause_AST = null;
try { // for error handling
Aast tmp1124_AST = null;
tmp1124_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1124_AST);
match(KW_BASE_KEY);
expr();
astFactory.addASTChild(currentAST, returnAST);
base_key_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_197);
}
returnAST = base_key_clause_AST;
}
/**
* Matches the <code>SECTION</code> clause and a required {@link #expr}.
* Used by {@link #get_key_value_stmt} and {@link #put_key_value_stmt}.
*/
public final void section_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast section_clause_AST = null;
try { // for error handling
Aast tmp1125_AST = null;
tmp1125_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1125_AST);
match(KW_SECTION);
expr();
astFactory.addASTChild(currentAST, returnAST);
section_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_198);
}
returnAST = section_clause_AST;
}
/**
* Matches the <code>KEY</code> clause and a required {@link #expr} or
* <code>DEFAULT</code> keyword. Used by {@link #get_key_value_stmt}
* and {@link #put_key_value_stmt}.
*/
public final void key_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast key_clause_AST = null;
try { // for error handling
Aast tmp1126_AST = null;
tmp1126_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1126_AST);
match(KW_KEY);
{
if ((LA(1)==KW_DEFAULT) && (LA(2)==KW_VALUE) && (_tokenSet_24.member(LA(3)))) {
Aast tmp1127_AST = null;
tmp1127_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1127_AST);
match(KW_DEFAULT);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
key_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_199);
}
returnAST = key_clause_AST;
}
/**
* Matches the <code>VALUE</code> clause and a required {@link #expr}.
* Used by {@link #get_key_value_stmt} and {@link #put_key_value_stmt}.
*/
public final void value_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast value_clause_AST = null;
try { // for error handling
Aast tmp1128_AST = null;
tmp1128_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1128_AST);
match(KW_VALUE);
expr();
astFactory.addASTChild(currentAST, returnAST);
value_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = value_clause_AST;
}
/**
* Matches the <code>COLOR or FONT</code> clause. Used by
* {@link #put_key_value_stmt}.
*/
public final void color_or_font_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast color_or_font_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_COLOR:
{
Aast tmp1129_AST = null;
tmp1129_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1129_AST);
match(KW_COLOR);
break;
}
case KW_FONT:
{
Aast tmp1130_AST = null;
tmp1130_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1130_AST);
match(KW_FONT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_ALL) && (LA(2)==DOT||LA(2)==KW_NO_ERROR) && (_tokenSet_11.member(LA(3)))) {
Aast tmp1131_AST = null;
tmp1131_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1131_AST);
match(KW_ALL);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
color_or_font_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = color_or_font_clause_AST;
}
/**
* Matches the <code>INPUT FROM and OUTPUT TO</code> language statements.
* References the following:
* <p>
* <ul>
* <li> {@link #value}
* <li> {@link #os_dir_clause}
* <li> {@link #filename}
* </ul>
* <p>
* Although it is undocumented, it is valid to use a string in place of a
* file or device name (without using the <code>VALUE</code> construct).
* The only documented use for this is in <code>OUTPUT TO</code> with the
* "CLIPBOARD" but it turns out that it can be more generally
* used.
* <p>
* This rule is called by {@link #io_stmt} which is what matches the
* <code>INPUT and OUTPUT</code> keywords. This refactoring allows all I/O
* statements to be supported without ambiguity.
*/
public final void io_from_to_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast io_from_to_stmt_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
boolean output = false;
{
{
switch ( LA(1)) {
case KW_FROM:
{
Aast tmp1132_AST = null;
tmp1132_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1132_AST);
match(KW_FROM);
break;
}
case KW_TO:
{
Aast tmp1133_AST = null;
tmp1133_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1133_AST);
match(KW_TO);
output = true;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_TERM) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1134_AST = null;
tmp1134_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1134_AST);
match(KW_TERM);
}
else if ((LA(1)==STRING) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.addASTChild(currentAST, s_AST);
match(STRING);
// convert the Progress string to a Java string
String txt = character.progressToJavaString(s_AST.getText(), !unixEscapes, false);
int newtype;
// determine the new type (this translates some special cases which the 4GL
// treats as keywords even though they were entered as string literals)
if (txt.equalsIgnoreCase("term") || txt.equalsIgnoreCase("terminal"))
{
newtype = KW_TERM;
}
else if (txt.equalsIgnoreCase("clipboard"))
{
newtype = KW_CLIP;
}
else if (txt.equalsIgnoreCase("web"))
{
newtype = KW_WEB;
}
else
{
// default
newtype = FILENAME;
}
saveAndReplaceTypeAndText(s_AST, newtype, txt);
}
else if ((LA(1)==KW_OS_DIR) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
os_dir_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_PRINTER) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( output )) {
printer_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_WEB) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( output )) {
Aast tmp1135_AST = null;
tmp1135_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1135_AST);
match(KW_WEB);
}
else if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
filename(null);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
io_from_to_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = io_from_to_stmt_AST;
}
/**
* Matches the <code>INPUT THROUGH/THRU, INPUT-OUTPUT THROUGH/THRU</code>
* and <code>OUTPUT THROUGH/THRU</code> language statements.
* <p>
* References the following:
* <p>
* <ul>
* <li> {@link #external_name_spec}
* <li> {@link #command_token_list}
* </ul>
* <p>
* Although it is undocumented, it is valid to use a string in place of a
* file or device name (without using the <code>VALUE</code> construct).
* <p>
* This rule is called by {@link #io_stmt} which is what matches the
* <code>INPUT, INPUT-OUTPUT and OUTPUT</code> keywords. This refactoring
* allows all I/O statements to be supported without ambiguity.
*/
public final void io_through_stmt() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast io_through_stmt_AST = null;
try { // for error handling
Aast tmp1136_AST = null;
tmp1136_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1136_AST);
match(KW_THROUGH);
{
external_name_spec();
astFactory.addASTChild(currentAST, returnAST);
}
command_token_list(true);
astFactory.addASTChild(currentAST, returnAST);
io_through_stmt_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = io_through_stmt_AST;
}
/**
* Matches the set of all I/O options and roots them at an <code>IO_OPTIONS</code> node.
* <p>
* This rule is called by {@link #io_stmt}.
*
* @param output
* If <code>true</code>, then this is an <code>OUTPUT</code> statement. Otherwise
* this is either an <code>INPUT</code> or <code>INPUT-OUTPUT</code> statement.
* @param thru
* If <code>true</code>, then this is an <code>INPUT THROUGH</code>,
* <code>INPUT-OUTPUT THROUGH</code> or <code>OUTPUT THROUGH</code> statement.
* Progress allows an undocumented <code>NO-ERROR</code> keyword in this
* case.
*/
public final void io_common_options(
boolean output, boolean thru
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast io_common_options_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(IO_OPTIONS,"options"));
{
_loop993:
do {
if ((_tokenSet_201.member(LA(1)))) {
io_options(output, thru);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop993;
}
} while (true);
}
io_common_options_AST = (Aast)currentAST.root;
if (io_common_options_AST.getNumberOfChildren() == 0) io_common_options_AST = null;
currentAST.root = io_common_options_AST;
currentAST.child = io_common_options_AST!=null &&io_common_options_AST.getFirstChild()!=null ?
io_common_options_AST.getFirstChild() : io_common_options_AST;
currentAST.advanceChildToEnd();
io_common_options_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = io_common_options_AST;
}
/**
* Matches the <code>OS-DIR</code> construct with its following parenthesized
* character {@link #expr} and options.
* <p>
* This rule is called by {@link #io_from_to_stmt}.
*/
public final void os_dir_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast os_dir_clause_AST = null;
try { // for error handling
Aast tmp1137_AST = null;
tmp1137_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1137_AST);
match(KW_OS_DIR);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NO_ATTRL:
{
Aast tmp1138_AST = null;
tmp1138_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1138_AST);
match(KW_NO_ATTRL);
break;
}
case DOT:
case KW_FONT:
case KW_MAP:
case KW_NO_ERROR:
case KW_NO_MAP:
case KW_APPEND:
case KW_BINARY:
case KW_COLLATE:
case KW_CONVERT:
case KW_ECHO:
case KW_KEEP_MSG:
case KW_LANDSCAP:
case KW_LOB_DIR:
case KW_NO_CVT:
case KW_NO_ECHO:
case KW_NUM_COPY:
case KW_PAGE_SZ:
case KW_PAGED:
case KW_PORTRAIT:
case KW_UNBUF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
os_dir_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = os_dir_clause_AST;
}
/**
* Matches the <code>PRINTER</code> keyword with its optional following
* printer name as matched by {@link #filename}.
* <p>
* This rule is called by {@link #io_from_to_stmt}.
*/
public final void printer_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast printer_clause_AST = null;
try { // for error handling
Aast tmp1139_AST = null;
tmp1139_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1139_AST);
match(KW_PRINTER);
{
if ((LA(1)==STRING) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1140_AST = null;
tmp1140_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1140_AST);
match(STRING);
}
else if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&(
LA(1) != KW_BINARY && LA(1) != KW_ECHO &&
LA(1) != KW_NO_ECHO && LA(1) != KW_UNBUF &&
LA(1) != KW_MAP && LA(1) != KW_NO_MAP &&
LA(1) != KW_NO_CVT && LA(1) != KW_CONVERT &&
LA(1) != KW_NUM_COPY && LA(1) != KW_PAGE_SZ &&
LA(1) != KW_COLLATE && LA(1) != KW_LANDSCAP &&
LA(1) != KW_PORTRAIT && LA(1) != KW_APPEND &&
LA(1) != KW_PAGED && LA(1) != KW_KEEP_MSG &&
LA(1) != KW_FONT
)) {
filename(null);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_190.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
printer_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = printer_clause_AST;
}
/**
* This rule implements the command token list processing for the shell
* command statements ({@link #shell_command_stmt}).
* <p>
* <b>This rule uses a trick to create an artificial node as a root while
* still allowing ANTLR to do normal tree building (no suppression of the
* AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used
* such that the contents of the loop cannot be referenced in a manually
* built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4) the
* ability to label a loop such that the entire contents can be referenced.
* If one labels the individual elements inside the loop, only the last one
* is available when the loop concludes. However, by leaving the normal
* tree creation unchanged but manually creating an artificial node and
* manually setting this node as the root of the returned tree BEFORE the
* children are added, this problem can be solved.
* <p>
* All children of the root node are one of the following types:
* <p>
* <pre>
* STRING
* COMMAND_TEXT
* KW_VALUE
* </pre>
* <p>
* The <code>COMMAND_TEXT</code> node is set as the type of any matched
* token which is not of the other two types. Since any token except
* <code>DOT</code> can be included here, these tokens MUST be rewritten
* otherwise downstream processing of the resulting tree would be quite
* difficult.
* <p>
* This rule only exists to create the proper AST, otherwise it would be much
* simpler to inline since the match is trivial.
*
* @param io_options
* <code>true</code> to avoid matching keywords that can be used
* as options in one of the I/O through statements.
*/
public final void command_token_list(
boolean io_options
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast command_token_list_AST = null;
Aast v_AST = null;
Token d = null;
Aast d_AST = null;
Token t = null;
Aast t_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(COMMAND_TOKENS,"tokens"));
int[] exclude = null;
// DOT and EOF are hard coded in the worker routine
if (io_options)
{
exclude = new int[]
{
KW_ECHO,
KW_NO_ECHO,
KW_UNBUF,
KW_MAP,
KW_NO_MAP,
KW_NO_CVT,
KW_CONVERT,
KW_PAGE_SZ,
KW_PAGED,
STRING,
KW_VALUE,
KW_NO_ERROR
};
}
else
{
exclude = new int[]
{
STRING,
KW_VALUE,
KW_NO_ERROR
};
}
mergeUntilWS(exclude);
{
_loop1827:
do {
switch ( LA(1)) {
case KW_VALUE:
{
value();
v_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
mergeUntilWS(exclude);
break;
}
case STRING:
{
Aast tmp1141_AST = null;
tmp1141_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1141_AST);
match(STRING);
mergeUntilWS(exclude);
break;
}
default:
if (((LA(1)==DOT) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( !followedByWhitespace(LT(1)) )) {
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.addASTChild(currentAST, d_AST);
match(DOT);
mergeUntilWS(exclude);
d_AST.setType(COMMAND_TEXT);
}
else if (((_tokenSet_202.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&(
LA(1) != KW_NO_ERROR &&
(!io_options ||
(LA(1) != KW_ECHO && LA(1) != KW_NO_ECHO &&
LA(1) != KW_UNBUF && LA(1) != KW_MAP &&
LA(1) != KW_NO_MAP && LA(1) != KW_NO_CVT &&
LA(1) != KW_CONVERT && LA(1) != KW_PAGE_SZ &&
LA(1) != KW_PAGED))
)) {
t = LT(1);
t_AST = (Aast)astFactory.create(t);
astFactory.addASTChild(currentAST, t_AST);
matchNot(DOT);
mergeUntilWS(exclude);
saveAndReplaceType(t_AST, COMMAND_TEXT);
}
else {
break _loop1827;
}
}
} while (true);
}
command_token_list_AST = (Aast)currentAST.root;
if (command_token_list_AST.getNumberOfChildren() == 0) command_token_list_AST = null;
currentAST.root = command_token_list_AST;
currentAST.child = command_token_list_AST!=null &&command_token_list_AST.getFirstChild()!=null ?
command_token_list_AST.getFirstChild() : command_token_list_AST;
currentAST.advanceChildToEnd();
command_token_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = command_token_list_AST;
}
/**
* Matches a range of options used in I/O language statements. Calls the
* following rules:
* <p>
* <ul>
* <li> {@link #value} (this is a qualifier for MAP, undocumented feature of the 4GL)
* <li> {@link #filename}
* <li> {@link #source_or_target_clause}
* <li> {@link #literal}
* <li> {@link #value}
* </ul>
* <p>
* The use of <code>literal and value</code> is made optional contrary to
* the Progress documentation since customer code was found where this was
* a valid construct.
* <p>
* Called by {@link #io_common_options}.
*
* @param output
* If <code>true</code>, then this is an <code>OUTPUT</code>
* statement. Otherwise this is either an <code>INPUT</code> or
* and <code>INPUT-OUTPUT</code> statement.
* @param thru
* If <code>true</code>, then this is an <code>INPUT THROUGH</code>,
* <code>INPUT-OUTPUT THROUGH</code> or <code>OUTPUT THROUGH</code> statement.
* Progress allows an undocumented <code>NO-ERROR</code> keyword in this
* case.
*/
public final void io_options(
boolean output, boolean thru
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast io_options_AST = null;
Token ap = null;
Aast ap_AST = null;
Token km = null;
Aast km_AST = null;
try { // for error handling
switch ( LA(1)) {
case KW_BINARY:
{
Aast tmp1142_AST = null;
tmp1142_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1142_AST);
match(KW_BINARY);
io_options_AST = (Aast)currentAST.root;
break;
}
case KW_ECHO:
case KW_NO_ECHO:
{
{
switch ( LA(1)) {
case KW_ECHO:
{
Aast tmp1143_AST = null;
tmp1143_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1143_AST);
match(KW_ECHO);
break;
}
case KW_NO_ECHO:
{
Aast tmp1144_AST = null;
tmp1144_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1144_AST);
match(KW_NO_ECHO);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
io_options_AST = (Aast)currentAST.root;
break;
}
case KW_UNBUF:
{
Aast tmp1145_AST = null;
tmp1145_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1145_AST);
match(KW_UNBUF);
io_options_AST = (Aast)currentAST.root;
break;
}
case KW_MAP:
{
Aast tmp1146_AST = null;
tmp1146_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1146_AST);
match(KW_MAP);
{
if ((LA(1)==STRING) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1147_AST = null;
tmp1147_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1147_AST);
match(STRING);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
filename(null);
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
io_options_AST = (Aast)currentAST.root;
break;
}
case KW_NO_MAP:
{
Aast tmp1148_AST = null;
tmp1148_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1148_AST);
match(KW_NO_MAP);
io_options_AST = (Aast)currentAST.root;
break;
}
case KW_LOB_DIR:
{
Aast tmp1149_AST = null;
tmp1149_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1149_AST);
match(KW_LOB_DIR);
{
switch ( LA(1)) {
case BOOL_TRUE:
case BOOL_FALSE:
case DEC_LITERAL:
case DATE_LITERAL:
case DATETIME_LITERAL:
case DATETIME_TZ_LITERAL:
case HEX_LITERAL:
case UNQUOTED_TEXT:
case KW_B_ENDIAN:
case KW_DLL_C_T:
case KW_EXC_LOCK:
case KW_FIND_CS:
case KW_FIND_GLO:
case KW_FIND_NO:
case KW_FIND_PO:
case KW_FIND_SEL:
case KW_FIND_WA:
case KW_FUNC_C_T:
case KW_GET_A_CT:
case KW_HOST_B_O:
case KW_L_ENDIAN:
case KW_NO_LOCK:
case KW_NO_WAIT:
case KW_PROC_C_T:
case KW_READ_AVL:
case KW_READ_E_N:
case KW_ROW_CRTD:
case KW_ROW_DELD:
case KW_ROW_MODD:
case KW_ROW_UMOD:
case KW_SAX_COMP:
case KW_SAX_PARE:
case KW_SAX_RUNN:
case KW_SAX_UNIN:
case KW_SAX_WBEG:
case KW_SAX_WCOM:
case KW_SAX_WCON:
case KW_SAX_WELM:
case KW_SAX_WERR:
case KW_SAX_WIDL:
case KW_SAX_WTAG:
case KW_SEAR_SLF:
case KW_SEAR_TRG:
case KW_SET_A_CT:
case KW_SH_LOCK:
case KW_WIN_DMIN:
case KW_WIN_MAX:
case KW_WIN_MIN:
case KW_WIN_NORM:
case STRING:
case UNKNOWN_VAL:
case NUM_LITERAL:
{
literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_VALUE:
{
value();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FONT:
case KW_MAP:
case KW_NO_ERROR:
case KW_NO_MAP:
case KW_APPEND:
case KW_BINARY:
case KW_COLLATE:
case KW_CONVERT:
case KW_ECHO:
case KW_KEEP_MSG:
case KW_LANDSCAP:
case KW_LOB_DIR:
case KW_NO_CVT:
case KW_NO_ECHO:
case KW_NUM_COPY:
case KW_PAGE_SZ:
case KW_PAGED:
case KW_PORTRAIT:
case KW_UNBUF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
io_options_AST = (Aast)currentAST.root;
break;
}
case KW_CONVERT:
case KW_NO_CVT:
{
codepage_convert_phrase();
astFactory.addASTChild(currentAST, returnAST);
io_options_AST = (Aast)currentAST.root;
break;
}
default:
if (((LA(1)==KW_NO_ERROR))&&( thru )) {
Aast tmp1150_AST = null;
tmp1150_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1150_AST);
match(KW_NO_ERROR);
io_options_AST = (Aast)currentAST.root;
}
else if (((LA(1)==KW_APPEND) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !output && !thru )) {
ap = LT(1);
ap_AST = (Aast)astFactory.create(ap);
match(KW_APPEND);
hide(ap);
io_options_AST = (Aast)currentAST.root;
}
else if (((LA(1)==KW_KEEP_MSG) && (_tokenSet_190.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !output )) {
km = LT(1);
km_AST = (Aast)astFactory.create(km);
match(KW_KEEP_MSG);
hide(km);
io_options_AST = (Aast)currentAST.root;
}
else if (((_tokenSet_203.member(LA(1))) && (_tokenSet_204.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( output )) {
{
switch ( LA(1)) {
case KW_NUM_COPY:
case KW_PAGE_SZ:
{
{
switch ( LA(1)) {
case KW_NUM_COPY:
{
Aast tmp1151_AST = null;
tmp1151_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1151_AST);
match(KW_NUM_COPY);
break;
}
case KW_PAGE_SZ:
{
Aast tmp1152_AST = null;
tmp1152_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1152_AST);
match(KW_PAGE_SZ);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case BOOL_TRUE:
case BOOL_FALSE:
case DEC_LITERAL:
case DATE_LITERAL:
case DATETIME_LITERAL:
case DATETIME_TZ_LITERAL:
case HEX_LITERAL:
case UNQUOTED_TEXT:
case KW_B_ENDIAN:
case KW_DLL_C_T:
case KW_EXC_LOCK:
case KW_FIND_CS:
case KW_FIND_GLO:
case KW_FIND_NO:
case KW_FIND_PO:
case KW_FIND_SEL:
case KW_FIND_WA:
case KW_FUNC_C_T:
case KW_GET_A_CT:
case KW_HOST_B_O:
case KW_L_ENDIAN:
case KW_NO_LOCK:
case KW_NO_WAIT:
case KW_PROC_C_T:
case KW_READ_AVL:
case KW_READ_E_N:
case KW_ROW_CRTD:
case KW_ROW_DELD:
case KW_ROW_MODD:
case KW_ROW_UMOD:
case KW_SAX_COMP:
case KW_SAX_PARE:
case KW_SAX_RUNN:
case KW_SAX_UNIN:
case KW_SAX_WBEG:
case KW_SAX_WCOM:
case KW_SAX_WCON:
case KW_SAX_WELM:
case KW_SAX_WERR:
case KW_SAX_WIDL:
case KW_SAX_WTAG:
case KW_SEAR_SLF:
case KW_SEAR_TRG:
case KW_SET_A_CT:
case KW_SH_LOCK:
case KW_WIN_DMIN:
case KW_WIN_MAX:
case KW_WIN_MIN:
case KW_WIN_NORM:
case STRING:
case UNKNOWN_VAL:
case NUM_LITERAL:
{
literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_VALUE:
{
value();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FONT:
case KW_MAP:
case KW_NO_ERROR:
case KW_NO_MAP:
case KW_APPEND:
case KW_BINARY:
case KW_COLLATE:
case KW_CONVERT:
case KW_ECHO:
case KW_KEEP_MSG:
case KW_LANDSCAP:
case KW_LOB_DIR:
case KW_NO_CVT:
case KW_NO_ECHO:
case KW_NUM_COPY:
case KW_PAGE_SZ:
case KW_PAGED:
case KW_PORTRAIT:
case KW_UNBUF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_COLLATE:
{
Aast tmp1153_AST = null;
tmp1153_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1153_AST);
match(KW_COLLATE);
break;
}
case KW_KEEP_MSG:
{
Aast tmp1154_AST = null;
tmp1154_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1154_AST);
match(KW_KEEP_MSG);
break;
}
case KW_LANDSCAP:
case KW_PORTRAIT:
{
{
switch ( LA(1)) {
case KW_LANDSCAP:
{
Aast tmp1155_AST = null;
tmp1155_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1155_AST);
match(KW_LANDSCAP);
break;
}
case KW_PORTRAIT:
{
Aast tmp1156_AST = null;
tmp1156_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1156_AST);
match(KW_PORTRAIT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case KW_APPEND:
{
Aast tmp1157_AST = null;
tmp1157_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1157_AST);
match(KW_APPEND);
break;
}
case KW_PAGED:
{
Aast tmp1158_AST = null;
tmp1158_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1158_AST);
match(KW_PAGED);
break;
}
case KW_FONT:
{
Aast tmp1159_AST = null;
tmp1159_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1159_AST);
match(KW_FONT);
{
switch ( LA(1)) {
case BOOL_TRUE:
case BOOL_FALSE:
case DEC_LITERAL:
case DATE_LITERAL:
case DATETIME_LITERAL:
case DATETIME_TZ_LITERAL:
case HEX_LITERAL:
case UNQUOTED_TEXT:
case KW_B_ENDIAN:
case KW_DLL_C_T:
case KW_EXC_LOCK:
case KW_FIND_CS:
case KW_FIND_GLO:
case KW_FIND_NO:
case KW_FIND_PO:
case KW_FIND_SEL:
case KW_FIND_WA:
case KW_FUNC_C_T:
case KW_GET_A_CT:
case KW_HOST_B_O:
case KW_L_ENDIAN:
case KW_NO_LOCK:
case KW_NO_WAIT:
case KW_PROC_C_T:
case KW_READ_AVL:
case KW_READ_E_N:
case KW_ROW_CRTD:
case KW_ROW_DELD:
case KW_ROW_MODD:
case KW_ROW_UMOD:
case KW_SAX_COMP:
case KW_SAX_PARE:
case KW_SAX_RUNN:
case KW_SAX_UNIN:
case KW_SAX_WBEG:
case KW_SAX_WCOM:
case KW_SAX_WCON:
case KW_SAX_WELM:
case KW_SAX_WERR:
case KW_SAX_WIDL:
case KW_SAX_WTAG:
case KW_SEAR_SLF:
case KW_SEAR_TRG:
case KW_SET_A_CT:
case KW_SH_LOCK:
case KW_WIN_DMIN:
case KW_WIN_MAX:
case KW_WIN_MIN:
case KW_WIN_NORM:
case STRING:
case UNKNOWN_VAL:
case NUM_LITERAL:
{
literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_VALUE:
{
value();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_FONT:
case KW_MAP:
case KW_NO_ERROR:
case KW_NO_MAP:
case KW_APPEND:
case KW_BINARY:
case KW_COLLATE:
case KW_CONVERT:
case KW_ECHO:
case KW_KEEP_MSG:
case KW_LANDSCAP:
case KW_LOB_DIR:
case KW_NO_CVT:
case KW_NO_ECHO:
case KW_NUM_COPY:
case KW_PAGE_SZ:
case KW_PAGED:
case KW_PORTRAIT:
case KW_UNBUF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
io_options_AST = (Aast)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_190);
}
returnAST = io_options_AST;
}
/**
* Matches the <code>SOURCE or TARGET</code> and following codepage or field
* construct which is matched as a {@link #expr}.
* <p>
* This rule is called by {@link #codepage_convert_phrase}, when it is
* matching codepages and by {@link #dde_get_stmt} or
* {@link #dde_request_stmt} or {@link #dde_send_stmt} when matching as a
* source or target field.
*
* @param cp
* <code>true</code> to allow the <code>CODEPAGE</code> keyword
* to be inserted between the <code>SOURCE</code> or
* <code>TARGET</code> and the following expression.
*/
public final void source_or_target_clause(
boolean cp
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast source_or_target_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_SOURCE:
{
Aast tmp1160_AST = null;
tmp1160_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1160_AST);
match(KW_SOURCE);
break;
}
case KW_TARGET:
{
Aast tmp1161_AST = null;
tmp1161_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1161_AST);
match(KW_TARGET);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==KW_CP) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( cp )) {
Aast tmp1162_AST = null;
tmp1162_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1162_AST);
match(KW_CP);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
source_or_target_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_205);
}
returnAST = source_or_target_clause_AST;
}
/**
* Matches the <code>MENU or SUB-MENU menu</code> reference seen in the
* {@link #widget_qualifier}. Other menu or sub-menu references (see
* {@link #widget_phrase}) are resolved by common/master processing in the
* {@link #lvalue} rule.
* <p>
* This is very similar to the {@link #submenu_descriptor} rule but it is
* much simpler. The two rules can't be used as alternatives because they
* are ambiguous.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* <code>MENU or SUB-MENU</code> keyword.
*/
public final void menu_reference() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast menu_reference_AST = null;
Aast menu_AST = null;
try { // for error handling
int ntype = WID_MENU;
{
switch ( LA(1)) {
case KW_MENU:
{
Aast tmp1163_AST = null;
tmp1163_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1163_AST);
match(KW_MENU);
break;
}
case KW_SUB_MENU:
{
Aast tmp1164_AST = null;
tmp1164_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1164_AST);
match(KW_SUB_MENU);
ntype = WID_SUB_MENU;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
symbol();
menu_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
menu_AST.setType(ntype);
menu_reference_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = menu_reference_AST;
}
/**
* Matches the <code>VIEW-AS COMBO-BOX</code> phrase which is called from a
* {@link #view_as_phrase}. Uses the following:
* <p>
* <ul>
* <li> {@link #list_items_clause}
* <li> {@link #inner_lines_clause}
* <li> {@link #size_phrase}
* <li> {@link #tooltip_clause}
* <li> {@link #max_chars_clause}
* <li> {@link #auto_completion_clause}
* </ul>
* <p>
* All options can be specified in any order.
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
*/
public final void combo_box_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast combo_box_phrase_AST = null;
try { // for error handling
Aast tmp1165_AST = null;
tmp1165_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1165_AST);
match(KW_COMBO_BX);
{
_loop1016:
do {
if ((LA(1)==KW_LST_PAIR||LA(1)==KW_LIST_ITM) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
list_items_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_INNER_L) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
inner_lines_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SORT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1166_AST = null;
tmp1166_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1166_AST);
match(KW_SORT);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DROP_DWN||LA(1)==KW_DROP_LST||LA(1)==KW_SIMPLE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SIMPLE:
{
Aast tmp1167_AST = null;
tmp1167_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1167_AST);
match(KW_SIMPLE);
break;
}
case KW_DROP_DWN:
{
Aast tmp1168_AST = null;
tmp1168_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1168_AST);
match(KW_DROP_DWN);
break;
}
case KW_DROP_LST:
{
Aast tmp1169_AST = null;
tmp1169_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1169_AST);
match(KW_DROP_LST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_MAX_CHAR) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
max_chars_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_AUTO_COM) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
auto_completion_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1016;
}
} while (true);
}
combo_box_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = combo_box_phrase_AST;
}
/**
* Matches the simplest form of <code>VIEW-AS</code> clauses for
* <code>FILL-IN, TEXT and TOGGLE-BOX</code>. See {@link #view_as_phrase}.
* Calls {@link #size_phrase} and {@link #tooltip_clause} rules.
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
* <p>
* This rule must return back a token type value to tell the caller which
* widget was specified, since it can match 3 different widgets and the
* caller must update the widget namespace.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*
* @return The token type of the matched widget name.
*/
public final int simple_widget_phrase() throws RecognitionException, TokenStreamException {
int ntype = -1;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast simple_widget_phrase_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_FILL_IN:
{
Aast tmp1170_AST = null;
tmp1170_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1170_AST);
match(KW_FILL_IN);
ntype = WID_FILL_IN;
break;
}
case KW_TEXT:
{
Aast tmp1171_AST = null;
tmp1171_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1171_AST);
match(KW_TEXT);
ntype = WID_TEXT;
break;
}
case KW_TOGGL_BX:
{
Aast tmp1172_AST = null;
tmp1172_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1172_AST);
match(KW_TOGGL_BX);
ntype = WID_TOGGLE;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop1020:
do {
if ((LA(1)==KW_NATIVE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1173_AST = null;
tmp1173_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1173_AST);
match(KW_NATIVE);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1020;
}
} while (true);
}
simple_widget_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = simple_widget_phrase_AST;
return ntype;
}
/**
* Matches the <code>VIEW-AS EDITOR</code> phrase which is called from a {@link #view_as_phrase}.
* <p>
* Under common conditions, the 4GL requires there be a size phrase or inner clause. However,
* there is an undocumented feature that allows the size phrase/inner clause to be missing
* SO LONG AS THE WIDGET HAS THEM SPECIFIED ELSEWHERE (e.g. in a DEFINE VARIABLE). This was
* found in customer source code. In other words, there must have been a previous VIEW-AS
* EDITOR clause with the proper minimum setup. We are not checking for that here. Instead,
* we are just loosening up the options processing to make it non-mandatory.
* <p>
* Uses the following:
* <p>
* <ul>
* <li> {@link #size_phrase}
* <li> {@link #inner_chars_and_lines_clause}
* <li> {@link #buffer_chars_or_lines_clause}
* <li> {@link #max_chars_clause}
* <li> {@link #tooltip_clause}
* </ul>
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are disabled.
* <p>
* All options can be specified in any order.
*/
public final void editor_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast editor_phrase_AST = null;
try { // for error handling
Aast tmp1174_AST = null;
tmp1174_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1174_AST);
match(KW_EDITOR);
{
_loop1024:
do {
if ((LA(1)==KW_BUFFER_C||LA(1)==KW_BUFFER_L) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
buffer_chars_or_lines_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LARGE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1175_AST = null;
tmp1175_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1175_AST);
match(KW_LARGE);
}
else if ((LA(1)==KW_MAX_CHAR) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
max_chars_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_NO_BOX) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1176_AST = null;
tmp1176_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1176_AST);
match(KW_NO_BOX);
}
else if ((LA(1)==KW_NO_WRAP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1177_AST = null;
tmp1177_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1177_AST);
match(KW_NO_WRAP);
}
else if ((LA(1)==KW_SCROLL_H) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1178_AST = null;
tmp1178_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1178_AST);
match(KW_SCROLL_H);
}
else if ((LA(1)==KW_SCROLL_V) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1179_AST = null;
tmp1179_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1179_AST);
match(KW_SCROLL_V);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_206.member(LA(1))) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SIZE:
case KW_SIZE_C:
case KW_SIZE_P:
{
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_INNER_C:
case KW_INNER_L:
{
inner_chars_and_lines_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop1024;
}
} while (true);
}
editor_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = editor_phrase_AST;
}
/**
* Matches the <code>VIEW-AS RADIO-SET</code> phrase which is called from a
* {@link #view_as_phrase}. Uses the following:
* <p>
* <ul>
* <li> {@link #size_phrase}
* <li> {@link #radio_buttons_clause}
* <li> {@link #tooltip_clause}
* </ul>
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
* <p>
* All options can be specified in any order.
*/
public final void radio_set_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast radio_set_phrase_AST = null;
try { // for error handling
Aast tmp1180_AST = null;
tmp1180_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1180_AST);
match(KW_RADIO_S);
{
_loop1029:
do {
if ((LA(1)==KW_HORIZ||LA(1)==KW_VERT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_HORIZ:
{
Aast tmp1181_AST = null;
tmp1181_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1181_AST);
match(KW_HORIZ);
{
if ((LA(1)==KW_EXPAND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1182_AST = null;
tmp1182_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1182_AST);
match(KW_EXPAND);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case KW_VERT:
{
Aast tmp1183_AST = null;
tmp1183_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1183_AST);
match(KW_VERT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_RADIO_B) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
radio_buttons_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1029;
}
} while (true);
}
radio_set_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = radio_set_phrase_AST;
}
/**
* Matches the <code>VIEW-AS SELECTION-LIST</code> phrase which is called
* from a {@link #view_as_phrase}. Uses the following:
* <p>
* <ul>
* <li> {@link #list_items_clause}
* <li> {@link #size_phrase}
* <li> {@link #inner_chars_and_lines_clause}
* <li> {@link #tooltip_clause}
* </ul>
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
* <p>
* All options can be specified in any order.
*/
public final void selection_list_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast selection_list_phrase_AST = null;
try { // for error handling
Aast tmp1184_AST = null;
tmp1184_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1184_AST);
match(KW_SEL_LST);
{
_loop1034:
do {
if ((LA(1)==KW_MULTIPLE||LA(1)==KW_SINGLE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SINGLE:
{
Aast tmp1185_AST = null;
tmp1185_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1185_AST);
match(KW_SINGLE);
break;
}
case KW_MULTIPLE:
{
Aast tmp1186_AST = null;
tmp1186_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1186_AST);
match(KW_MULTIPLE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_DRAG) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1187_AST = null;
tmp1187_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1187_AST);
match(KW_NO_DRAG);
}
else if ((LA(1)==KW_LST_PAIR||LA(1)==KW_LIST_ITM) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
list_items_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SCROLL_H) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1188_AST = null;
tmp1188_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1188_AST);
match(KW_SCROLL_H);
}
else if ((LA(1)==KW_SCROLL_V) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1189_AST = null;
tmp1189_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1189_AST);
match(KW_SCROLL_V);
}
else if ((_tokenSet_206.member(LA(1))) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_SIZE:
case KW_SIZE_C:
case KW_SIZE_P:
{
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_INNER_C:
case KW_INNER_L:
{
inner_chars_and_lines_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_SORT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1190_AST = null;
tmp1190_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1190_AST);
match(KW_SORT);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1034;
}
} while (true);
}
selection_list_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = selection_list_phrase_AST;
}
/**
* Matches the <code>VIEW-AS SLIDER</code> phrase which is called
* from a {@link #view_as_phrase}. Uses the following:
* <p>
* <ul>
* <li> {@link #max_and_min_value_clause}
* <li> {@link #tic_marks_clause}
* <li> {@link #size_phrase}
* <li> {@link #tooltip_clause}
* </ul>
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
* <p>
* All options can be specified in any order.
*/
public final void slider_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast slider_phrase_AST = null;
try { // for error handling
Aast tmp1191_AST = null;
tmp1191_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1191_AST);
match(KW_SLIDER);
{
_loop1038:
do {
if ((LA(1)==KW_HORIZ||LA(1)==KW_VERT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_HORIZ:
{
Aast tmp1192_AST = null;
tmp1192_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1192_AST);
match(KW_HORIZ);
break;
}
case KW_VERT:
{
Aast tmp1193_AST = null;
tmp1193_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1193_AST);
match(KW_VERT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==KW_NO_CUR_V) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1194_AST = null;
tmp1194_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1194_AST);
match(KW_NO_CUR_V);
}
else if ((LA(1)==KW_LG_2_SM) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1195_AST = null;
tmp1195_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1195_AST);
match(KW_LG_2_SM);
}
else if ((LA(1)==KW_MAX_VAL||LA(1)==KW_MIN_VAL) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
max_and_min_value_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TIC_MARK) && (_tokenSet_207.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tic_marks_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= KW_SIZE && LA(1) <= KW_SIZE_P)) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (LA(3)==KW_BY)) {
size_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TOOLTIP) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
tooltip_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1038;
}
} while (true);
}
slider_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = slider_phrase_AST;
}
/**
* Matches the <code>LIST_ITEMS</code> and <code>LIST_ITEM_PAIRS</code> clauses as used in a
* phrase from a <code>VIEW-AS COMBO-BOX</code> or <code>VIEW-AS SELECTION-LIST</code> construct.
* See {@link #combo_box_phrase} or {@link #selection_list_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the AST is kept simple
* because all tokens can be rooted at this option's keyword.
*/
public final void list_items_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast list_items_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_LIST_ITM:
{
Aast tmp1196_AST = null;
tmp1196_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1196_AST);
match(KW_LIST_ITM);
break;
}
case KW_LST_PAIR:
{
Aast tmp1197_AST = null;
tmp1197_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1197_AST);
match(KW_LST_PAIR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
literal();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1059:
do {
if ((LA(1)==COMMA) && (_tokenSet_65.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
comma();
astFactory.addASTChild(currentAST, returnAST);
literal();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1059;
}
} while (true);
}
list_items_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = list_items_clause_AST;
}
/**
* Matches the <code>INNER-LINES</code> clause as used in a phrase from a
* <code>VIEW-AS COMBO-BOX</code> construct. See {@link #combo_box_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void inner_lines_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast inner_lines_clause_AST = null;
try { // for error handling
Aast tmp1198_AST = null;
tmp1198_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1198_AST);
match(KW_INNER_L);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
inner_lines_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = inner_lines_clause_AST;
}
/**
* Matches the <code>MAX-CHARS</code> clause as used in a phrase from a
* <code>VIEW-AS COMBO-BOX</code> construct. See {@link #combo_box_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void max_chars_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast max_chars_clause_AST = null;
try { // for error handling
Aast tmp1199_AST = null;
tmp1199_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1199_AST);
match(KW_MAX_CHAR);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
max_chars_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = max_chars_clause_AST;
}
/**
* Matches the <code>AUTO-COMPLETION</code> clause as used in a phrase from a
* <code>VIEW-AS COMBO-BOX</code> construct. See {@link #combo_box_phrase}.
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void auto_completion_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast auto_completion_clause_AST = null;
try { // for error handling
Aast tmp1200_AST = null;
tmp1200_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1200_AST);
match(KW_AUTO_COM);
{
if ((LA(1)==KW_UNIQ_MAT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1201_AST = null;
tmp1201_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1201_AST);
match(KW_UNIQ_MAT);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
auto_completion_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = auto_completion_clause_AST;
}
/**
* Matches the <code>BUFFER-CHARS chars and BUFFER-LINES lines</code> clause
* as used in a <code>VIEW-AS EDITOR</code> phrase. See
* {@link #view_as_phrase} and {@link #editor_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void buffer_chars_or_lines_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast buffer_chars_or_lines_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_BUFFER_C:
{
Aast tmp1202_AST = null;
tmp1202_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1202_AST);
match(KW_BUFFER_C);
break;
}
case KW_BUFFER_L:
{
Aast tmp1203_AST = null;
tmp1203_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1203_AST);
match(KW_BUFFER_L);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
buffer_chars_or_lines_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = buffer_chars_or_lines_clause_AST;
}
/**
* Matches the <code>INNER-CHARS chars INNER-LINES lines</code> clause in an
* arbitrary order (either keyword will be matched first, which is an
* undocumented feature. Although the documentation states both must be
* present to complete the match, working 4GL code has also shown that it is
* valid to match only one of the two. As another undocumented feature, the
* second keyword and literal has been made optional. This causes some
* ambiguity to be detected, but the usage is fine. For this reason, the
* warning has been disabled.
* <p>
* See {@link #inner_chars_and_lines_core}
*/
public final void inner_chars_and_lines_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast inner_chars_and_lines_clause_AST = null;
try { // for error handling
inner_chars_and_lines_core();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_INNER_C||LA(1)==KW_INNER_L) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
inner_chars_and_lines_core();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
inner_chars_and_lines_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = inner_chars_and_lines_clause_AST;
}
/**
* Matches the {@code RADIO-BUTTONS} clause as used in a {@code VIEW-AS RADIO-SET} phrase. See
* {@link #view_as_phrase} and {@link #radio_set_phrase}. The root node will be a {@code KW_RADIO_B}
* followed by pairs of {@code STRING} and {@code literal}. Although the documentation suggests that
* the first element of every pair is a {@code STRING}, but an undocumented feature of the 4GL is that
* this can also be unquoted text (including non-symbol characters). This is matched using the
* {@code malformed_symbol} rules. If this quirk is found, that node is rewritten from {@code SYMBOL} to
* {@code STRING} so that the downstream code can be simple.
* <p>
* By making a separate rule for this, the logic is centralized and the AST is kept simple because all
* tokens can be rooted at this option's keyword.
*/
public final void radio_buttons_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast radio_buttons_clause_AST = null;
Aast s1_AST = null;
Aast s2_AST = null;
try { // for error handling
Aast tmp1204_AST = null;
tmp1204_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1204_AST);
match(KW_RADIO_B);
{
if ((LA(1)==STRING) && (LA(2)==COMMA) && (_tokenSet_65.member(LA(3)))) {
Aast tmp1205_AST = null;
tmp1205_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1205_AST);
match(STRING);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
malformed_symbol();
s1_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
convertSymbolToString(s1_AST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
comma();
astFactory.addASTChild(currentAST, returnAST);
literal();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1048:
do {
if ((LA(1)==COMMA) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
comma();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==STRING) && (LA(2)==COMMA) && (_tokenSet_65.member(LA(3)))) {
Aast tmp1206_AST = null;
tmp1206_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1206_AST);
match(STRING);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
malformed_symbol();
s2_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
convertSymbolToString(s2_AST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
comma();
astFactory.addASTChild(currentAST, returnAST);
literal();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1048;
}
} while (true);
}
radio_buttons_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = radio_buttons_clause_AST;
}
/**
* Matches the <code>MAX-VALUE num</code> or <code>MIN-VALUE num</code>
* clauses as used in a <code>VIEW-AS SLIDER</code> phrase. See
* {@link #view_as_phrase} and {@link #slider_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void max_and_min_value_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast max_and_min_value_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_MAX_VAL:
{
Aast tmp1207_AST = null;
tmp1207_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1207_AST);
match(KW_MAX_VAL);
break;
}
case KW_MIN_VAL:
{
Aast tmp1208_AST = null;
tmp1208_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1208_AST);
match(KW_MIN_VAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
max_and_min_value_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = max_and_min_value_clause_AST;
}
/**
* Matches the <code>TIC-MARKS</code> clause as used in a
* <code>VIEW-AS SLIDER</code> phrase. See {@link #view_as_phrase}
* and {@link #slider_phrase}.
* <p>
* ANTLR detects ambiguity but there is no real problem. Warnings are
* disabled.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void tic_marks_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast tic_marks_clause_AST = null;
try { // for error handling
Aast tmp1209_AST = null;
tmp1209_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1209_AST);
match(KW_TIC_MARK);
{
switch ( LA(1)) {
case KW_NONE:
{
Aast tmp1210_AST = null;
tmp1210_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1210_AST);
match(KW_NONE);
break;
}
case KW_TOP:
{
Aast tmp1211_AST = null;
tmp1211_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1211_AST);
match(KW_TOP);
break;
}
case KW_BOTTOM:
{
Aast tmp1212_AST = null;
tmp1212_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1212_AST);
match(KW_BOTTOM);
break;
}
case KW_LEFT:
{
Aast tmp1213_AST = null;
tmp1213_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1213_AST);
match(KW_LEFT);
break;
}
case KW_RIGHT:
{
Aast tmp1214_AST = null;
tmp1214_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1214_AST);
match(KW_RIGHT);
break;
}
case KW_BOTH:
{
Aast tmp1215_AST = null;
tmp1215_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1215_AST);
match(KW_BOTH);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_FREQ) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1216_AST = null;
tmp1216_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1216_AST);
match(KW_FREQ);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
tic_marks_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = tic_marks_clause_AST;
}
/**
* Matches the <code>INNER-CHARS chars or INNER-LINES lines</code> clause as
* used in a <code>VIEW-AS EDITOR</code> phrase. See {@link #view_as_phrase}
* and {@link #editor_phrase}.
* <p>
* By making a separate rule for this, the logic is centralized and the
* AST is kept simple because all tokens can be rooted at this option's
* keyword.
*/
public final void inner_chars_and_lines_core() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast inner_chars_and_lines_core_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_INNER_C:
{
Aast tmp1217_AST = null;
tmp1217_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1217_AST);
match(KW_INNER_C);
break;
}
case KW_INNER_L:
{
Aast tmp1218_AST = null;
tmp1218_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1218_AST);
match(KW_INNER_L);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
inner_chars_and_lines_core_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = inner_chars_and_lines_core_AST;
}
/**
* Matches a Progress 4GL label reference that refers to a label that was
* previously defined in a block definition, see {@link #inner_block}.
* <p>
* The matching portion of this rule is defined as a single token that
* matches the union of the label token type and the set of all possible
* alternatives for symbol names. Normally, symbols must start with an
* alphabetic character or underscore, but labels are special in that they
* can be malformed. This means they can start with any valid symbol
* character (such as a minus, a number or other characters). To implement
* this, a call to {@link #malformed_symbol} rule is used.
* <p>
* Since the <code>malformed_symbol</code> rule includes reserved keywords
* in its possible token set, if the calling rule has following tokens that
* map into this set, there will be a potentially inappropriate matching to
* this rule. For this reason, this rule may return nothing if it detects
* that there is no label reference at all.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> since this could be anything. What we
* really require is a token that is a <code>LABEL</code>. The result of
* this rule is always rewritten to have the <code>LABEL</code> type.
*/
public final void label_reference() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast label_reference_AST = null;
try { // for error handling
// save off this token for error handling later
Token lead = LT(1);
int ttype = lead.getType();
boolean proper = false;
boolean mal = false;
// check if this a normal label
if ((ttype > BEGIN_UNRESERVED && ttype < END_UNRESERVED) ||
ttype == SYMBOL)
{
if (sym.lookupLabel(lead.getText()) != -1)
{
proper = true;
}
}
if (!proper)
{
mal = isMalformedLabel(false, 1, null);
}
{
if ((LA(1)==LABEL) && (_tokenSet_101.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1219_AST = null;
tmp1219_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1219_AST);
match(LABEL);
}
else if ((((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( proper || mal || LA(3) == KW_THROW)) {
malformed_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_101.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
label_reference_AST = (Aast)currentAST.root;
if (label_reference_AST != null)
{
ttype = label_reference_AST.getType();
if (ttype != LABEL)
{
int newtype = sym.lookupLabel(label_reference_AST.getText());
if (newtype == -1 && LA(2) == KW_THROW)
{
// bogus label for UNDO, THROW
newtype = LABEL;
}
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if ( newtype != -1 )
{
label_reference_AST.setType( newtype );
}
else
{
throw new NoViableAltException(lead, getFilename());
}
}
}
label_reference_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_101);
}
returnAST = label_reference_AST;
}
/**
* Matches the <code>GET</code> or <code>SET</code> block of the
* {@link #def_prop_stmt}. Uses {@link #access_mode}, {@link #param_list_definition},
* {@link #block} and {@link #end_stmt}.
*/
public final void getter_setter() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast getter_setter_AST = null;
Aast a_AST = null;
Token g = null;
Aast g_AST = null;
Token s = null;
Aast s_AST = null;
Aast p_AST = null;
Aast b_AST = null;
try { // for error handling
nestLevel++;
sym.addScope();
sym.addSchemaScope(true);
boolean oldBufScope = bufferScope;
bufferScope = false;
inMethodDef = true;
sym.setInMethod(true);
{
switch ( LA(1)) {
case KW_PK_PRIV:
case KW_PK_PROT:
case KW_PRIVATE:
case KW_PROTECTD:
case KW_PUBLIC:
{
access_mode();
a_AST = (Aast)returnAST;
break;
}
case KW_SET:
case KW_GET:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_GET:
{
g = LT(1);
g_AST = (Aast)astFactory.create(g);
match(KW_GET);
break;
}
case KW_SET:
{
s = LT(1);
s_AST = (Aast)astFactory.create(s);
match(KW_SET);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (!( nestLevel == 2 ))
throw new SemanticException(" nestLevel == 2 ");
{
if ((LA(1)==COLON||LA(1)==LPARENS) && (_tokenSet_208.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case LPARENS:
{
param_list_definition(false, false, true);
p_AST = (Aast)returnAST;
block_term();
break;
}
case COLON:
{
colon();
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
block();
b_AST = (Aast)returnAST;
{
switch ( LA(1)) {
case KW_END:
{
end_stmt(false);
break;
}
case DOT:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==DOT||LA(1)==COLON) && (_tokenSet_11.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
getter_setter_AST = (Aast)currentAST.root;
Aast proproot = g_AST == null ? s_AST : g_AST;
Aast blk = b_AST == null ? null : (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(BLOCK,"block")).add(b_AST));
getter_setter_AST = (Aast)astFactory.make( (new ASTArray(4)).add(proproot).add(a_AST).add(p_AST).add(blk));
// getters/setters are always nested
bufferScope = oldBufScope;
inMethodDef = false;
sym.setInMethod(false);
// don't know if getters/setters propagate, assume true for now (assume same with
// user_defined_method)
sym.deleteSchemaScope(true);
sym.deleteScope();
inStaticCtxt = false;
nestLevel--;
currentAST.root = getter_setter_AST;
currentAST.child = getter_setter_AST!=null &&getter_setter_AST.getFirstChild()!=null ?
getter_setter_AST.getFirstChild() : getter_setter_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_32);
}
returnAST = getter_setter_AST;
}
/**
* Match the specification of an event handler signature for a 4GL procedure or method that
* will handle the associated event. Called from {@link #def_event_stmt}. Matches an optional
* <code>KW_SIGNATUR</code>, then a <code>KW_VOID</code> followed by a
* {@link #param_list_definition}. The result is rooted at an <code>EVENT_SIGNATURE</code>
* node. Separated from the main rule in order to build the tree properly.
*/
public final void event_signature() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast event_signature_AST = null;
Token si = null;
Aast si_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(EVENT_SIGNATURE,"signature"));
sym.setInMethod(true);
{
switch ( LA(1)) {
case KW_SIGNATUR:
{
si = LT(1);
si_AST = (Aast)astFactory.create(si);
match(KW_SIGNATUR);
hide(si);
break;
}
case KW_VOID:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp1220_AST = null;
tmp1220_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1220_AST);
match(KW_VOID);
param_list_definition(true, false, true);
astFactory.addASTChild(currentAST, returnAST);
sym.setInMethod(false);
event_signature_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = event_signature_AST;
}
/**
* Match the specification of an event handler as a .NET delegate class name
* that will handle the associated event. Called from {@link #def_event_stmt}.
* Matches an optional <code>KW_DELEGATE</code>, then an optional
* <code>KW_CLASS</code> followed by an {@link #user_defined_type_name}. The
* result is rooted at an <code>DOTNET_DELEGATE</code> node. Separated from the
* main rule in order to build the tree properly.
*/
public final void dotnet_delegate() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dotnet_delegate_AST = null;
Token del = null;
Aast del_AST = null;
Token cl = null;
Aast cl_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(DOTNET_DELEGATE,"delegate"));
{
if ((LA(1)==KW_DELEGATE) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
del = LT(1);
del_AST = (Aast)astFactory.create(del);
match(KW_DELEGATE);
hide(del);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_CLASS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLASS);
hide(cl);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
dotnet_delegate_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = dotnet_delegate_AST;
}
/**
* Matches a {@link #literal} or an {@link #lvalue} when the
* <code>TODAY</code> or <code>NOW</code> keywords are encountered. Handles a
* special case for {@link #initializer} but instead of resolving to a
* <code>FUNC_DATE</code> or <code>FUNC_DATETIME</code> we override the type
* to <code>DATE_LITERAL</code>, <code>DATETIME_LITERAL</code> or <code>DATETIME_TZ_LITERAL</code>
* which is consistent with the usage of this as a constant.
* <p>
* Due to nastiness in Progress, there is an undocumented 'feature' that
* allows one to specify a non-string literal as a string. This is a problem
* when one needs to find a token of one type and finds a <code>STRING</code>
* instead. For this reason, all callers now provide a state parameter that
* determines if any possible fixups are needed. If so, the init rule
* rewrites the token properly.
* <p>
* <b>WARNING: in combination with the above feature, if a logical value is
* initialized with a string, the format string (implicitly set to 'yes/no'
* and 'true/false' or explicitly set via <code>LIKE or FORMAT</code>) will
* determine how such strings will be converted to
* <code>BOOL_TRUE or BOOL_FALSE</code>. Since the format string may or may
* not be known at this point in the parsing, the result cannot be determined
* in this rule. In this case the original <code>STRING</code> is left
* behind and will be handled by our 'boolean manhandling' processing later.
* </b>
*
* @param vtype
* A token type that describes type of the variable being initialized. This is
* the type of the child of the <code>KW_AS</code> or <code>KW_LIKE</code> node.
*/
public final void initializer_constant(
int vtype
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast initializer_constant_AST = null;
Aast l_AST = null;
try { // for error handling
boolean string = isCharType(vtype);
boolean date = isDateType(vtype);
boolean numeric = isNumericType(vtype);
Token content = LT(1);
String oldtxt = content.getText();
String newtxt = null;
int oldtype = content.getType();
int newtype = -1;
// character type needs this manhandling too
if (string)
{
if (oldtype != STRING && oldtype != UNKNOWN_VAL)
{
// wrap this in quotes
newtxt = "\"" + oldtxt + "\"";
newtype = STRING;
}
}
else
{
// the SYMBOL case will happen in the "boolean manhandling" situation
// only handle the STRING case here
if (oldtype == STRING)
{
// OK, we need to re-lex!
Token fixed = relex(oldtxt);
// nulls should only occur if the input is the empty string
if (fixed == null)
{
// empty string is the same as unknown value in a 4GL date init
if (date)
{
newtxt = "?";
newtype = UNKNOWN_VAL;
}
else if (numeric)
{
// empty string is the same as the 0 value in a 4GL numeric init
newtxt = "0";
newtype = NUM_LITERAL;
}
}
else
{
if (oldtype == STRING && (isDateTimeType(vtype) || isDateTimeTzType(vtype)))
{
// relex will eat everything after a 'space' char, this ensures the literal is preserved
// this literal is not a ISO literal, but the string specification of a datetime(-tz)
fixed = content;
// mark the literal to be wrapped in a datetime or datetime-tz
newtxt = character.progressToJavaString(oldtxt, !unixEscapes, false);
newtype = isDateTimeType(vtype) ? DATETIME_LITERAL : DATETIME_TZ_LITERAL;
}
else
{
int t = fixed.getType();
// only update the type and text if we found a new match,
// otherwise defer the fix to later...
if (t == UNKNOWN_VAL || t == BOOL_TRUE || t == BOOL_FALSE ||
t == NUM_LITERAL || t == HEX_LITERAL || t == DEC_LITERAL ||
t == DATE_LITERAL || t == DATETIME_LITERAL || t == KW_TODAY ||
t == DATETIME_TZ_LITERAL || t == KW_NOW)
{
newtxt = fixed.getText();
newtype = fixed.getType();
}
}
}
}
}
// date types allow matching of the text that in other known contexts would
// be a decimal literal, we must rewrite those cases here
if (date)
{
if (oldtype == DEC_LITERAL)
{
newtype = DATE_LITERAL;
}
}
if (newtxt != null)
{
content.setText(newtxt);
}
if (newtype != -1 && newtype != oldtype)
{
content.setType(newtype);
}
{
if ((_tokenSet_65.member(LA(1)))) {
literal();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_64.member(LA(1))))&&( LA(1) == KW_TODAY || LA(1) == KW_NOW )) {
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// don't use saveAndReplaceType() here because we already have
// the KW_TODAY/KW_NOW as our "oldtype" annotation and we are
// just replacing the FUNC_* type that is the current type with
// the literal type which eases our conversion effort in this
// case since this is the only case where Progress treats these
// "functions" as literals
if (l_AST.getType() == FUNC_DATE)
{
// today
l_AST.setType(DATE_LITERAL);
}
else if (l_AST.getType() == FUNC_DATETIME_TZ)
{
// now
l_AST.setType(DATETIME_TZ_LITERAL);
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
initializer_constant_AST = (Aast)currentAST.root;
if (newtxt != null)
{
initializer_constant_AST.putAnnotation("original-text", oldtxt);
}
if (newtype != -1 && newtype != oldtype)
{
initializer_constant_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
}
initializer_constant_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = initializer_constant_AST;
}
/**
* Matches the variable type language keyword in {@link #as_clause} or
* directly in {@link #parameter}.
* <p>
* This design allows the logic to be centralized and reused from multiple
* callers. To do this, this rule requires a single parameter which is the
* variable name to be added to the dictionary. This is necessary since there
* is no way to implement a standard match for the symbol name from all
* language statements that call this rule.
* <p>
* The inclusion of the {@link #reserved_or_symbol} rule in the second token
* position ensures that all possible symbols are considered a possible data
* type and will be matched by this rule. This means that the calling rules
* include a list of reserved and unreserved keywords or generic symbols as
* one of the options for its 2nd token, thus "pulling" the
* recursive descent processing down into this rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code>, random keyword match or anything
* other than one of the valid <b>special abbreviations</b> for a data type.
* What we really require is a token that is one of the following:
* <pre>
* Data Type Keyword Actual Minimum Abbrev Lexer Abbrev
* ----------------- --------------------- -------------
* KW_BLOB not supported as a variable
* KW_CHAR c char
* KW_CLASS n/a n/a
* KW_CLOB not supported as a variable
* KW_COM_HNDL n/a n/a
* KW_DATE da n/a
* KW_DATETIME n/a n/a
* KW_DATE_TZ n/a n/a
* KW_DEC de dec
* KW_HANDLE handle n/a
* KW_INT i int
* KW_INT64 n/a n/a
* KW_LOGICAL l n/a
* KW_LONGCHAR n/a n/a
* KW_MEMPTR m mem
* KW_RAW ra n/a
* KW_RECID re n/a
* KW_ROWID row n/a
* KW_WID_HAND widg widget-h
* The following are supported in native interfaces:
* KW_BYTE n/a n/a
* KW_DOUBLE n/a n/a
* KW_FLOAT n/a n/a
* KW_LONG n/a n/a
* KW_SHORT n/a n/a
* KW_UNS_SHRT n/a n/a
* </pre>
* <p>
* The difference between a <code>SYMBOL</code> and a <code>KW_CHAR</code>
* can only be determined by context (the fact that the lookahead code has
* identified a match with a <code>SYMBOL</code> token which is a construct
* that can occur in an this rule). Thus <b>if</b> a match is found using
* lookahead (in the rule that calls this one), then it <b>must</b> be
* correct and necessary to convert the <code>SYMBOL</code> or other keyword
* token type into the correct keyword representing the data type, using a
* special abbreviation test. This is done in an init action that is
* processed at the beginning of this rule. In this way, the rest of the rule
* only sees the 2nd token as a data token type and never tries to
* call the <code>reserved_or_symbol</code> rule since calling that rule
* would actually try to match (and consume from the token stream) a
* <code>SYMBOL</code> or other keyword token type. <b>Specifying a rule
* reference to obtain its value from a lookahead perspective but then
* changing the token's type such that the rule reference never gets called,
* is the critical trick that enables context sensitive symbol names!</b>
* <p>
* This use of a pull rule is only necessary because Progress provides
* additional special abbreviation support in this construct. This is a set
* of reduced abbreviations (see table above) beyond the normal (documented
* or undocumented) abbreviations of a data type keyword as is possible
* elsewhere in Progress source code. The <code>reserved_or_symbol</code>
* is needed because some possible reserved keyword matches could occur
* that would match one of these special abbreviations and thus the
* <code>symbol</code> rule would not be sufficient to pull all possible
* valid keyword matches into this rule.
* <p>
* The init action reads the text of the 2nd token and switches the token
* type to that of the matching data type keyword, if any special
* abbreviation is found. All such processing is bypassed if the lexer
* has already matched a valid data type keyword.
* <p>
* The logic of the special abbreviation processing is centralized in the
* specialDataTypeKeywordAbbreviations() method.
* <p>
* Note that this rule does support the addition of scoped shared and global
* shared variables. No special steps are necessary to enable this due to
* a quirk in how Progress handles such variables, they can only be defined
* in the top-level context (not inside a procedure or function which is the
* only block in which there is a different scoping level). For this reason,
* whenever shared variables are added to the dictionary, they can be added
* to the current scope, since this is the same as the global scope in any
* valid Progress code.
*
* @param varName
* Text which is the variable name that should be added to the
* current scope of the variable dictionary. If <code>null</code>,
* no name will be added and this clause is essentially ignored.
* @param nativeTypes
* <code>true</code> to support extra type keywords for native
* shared library interfaces.
*/
public final void var_type(
String varName, boolean nativeTypes
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast var_type_AST = null;
Token cl = null;
Aast cl_AST = null;
Aast nam_AST = null;
try { // for error handling
int vartype = -1;
specialDataTypeKeywordAbbreviations(1);
{
if ((LA(1)==KW_CHAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1221_AST = null;
tmp1221_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1221_AST);
match(KW_CHAR);
vartype = VAR_CHAR;
}
else if ((LA(1)==KW_COM_HNDL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1222_AST = null;
tmp1222_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1222_AST);
match(KW_COM_HNDL);
vartype = VAR_COM_HANDLE;
}
else if ((LA(1)==KW_DATE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1223_AST = null;
tmp1223_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1223_AST);
match(KW_DATE);
vartype = VAR_DATE;
}
else if ((LA(1)==KW_DATETIME) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1224_AST = null;
tmp1224_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1224_AST);
match(KW_DATETIME);
vartype = VAR_DATETIME;
}
else if ((LA(1)==KW_DATE_TZ) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1225_AST = null;
tmp1225_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1225_AST);
match(KW_DATE_TZ);
vartype = VAR_DATETIME_TZ;
}
else if ((LA(1)==KW_DEC) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1226_AST = null;
tmp1226_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1226_AST);
match(KW_DEC);
vartype = VAR_DEC;
}
else if ((LA(1)==KW_HANDLE||LA(1)==KW_WID_HAND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case KW_HANDLE:
{
Aast tmp1227_AST = null;
tmp1227_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1227_AST);
match(KW_HANDLE);
break;
}
case KW_WID_HAND:
{
Aast tmp1228_AST = null;
tmp1228_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1228_AST);
match(KW_WID_HAND);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
vartype = VAR_HANDLE;
}
else if ((LA(1)==KW_INT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1229_AST = null;
tmp1229_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1229_AST);
match(KW_INT);
vartype = VAR_INT;
}
else if ((LA(1)==KW_INT64) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1230_AST = null;
tmp1230_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1230_AST);
match(KW_INT64);
vartype = VAR_INT64;
}
else if ((LA(1)==KW_LOGICAL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1231_AST = null;
tmp1231_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1231_AST);
match(KW_LOGICAL);
vartype = VAR_LOGICAL;
}
else if ((LA(1)==KW_LONGCHAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1232_AST = null;
tmp1232_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1232_AST);
match(KW_LONGCHAR);
vartype = VAR_LONGCHAR;
}
else if ((LA(1)==KW_RECID) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1233_AST = null;
tmp1233_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1233_AST);
match(KW_RECID);
vartype = VAR_RECID;
}
else if ((LA(1)==KW_ROWID) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1234_AST = null;
tmp1234_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1234_AST);
match(KW_ROWID);
vartype = VAR_ROWID;
}
else if ((LA(1)==KW_RAW) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1235_AST = null;
tmp1235_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1235_AST);
match(KW_RAW);
vartype = VAR_RAW;
}
else if ((LA(1)==KW_MEMPTR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1236_AST = null;
tmp1236_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1236_AST);
match(KW_MEMPTR);
vartype = VAR_MEMPTR;
}
else if ((LA(1)==KW_POLY) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1237_AST = null;
tmp1237_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1237_AST);
match(KW_POLY);
vartype = VAR_POLY;
}
else if (((_tokenSet_209.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( nativeTypes )) {
{
switch ( LA(1)) {
case KW_BYTE:
{
Aast tmp1238_AST = null;
tmp1238_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1238_AST);
match(KW_BYTE);
vartype = VAR_BYTE;
break;
}
case KW_DOUBLE:
{
Aast tmp1239_AST = null;
tmp1239_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1239_AST);
match(KW_DOUBLE);
vartype = VAR_DOUBLE;
break;
}
case KW_FLOAT:
{
Aast tmp1240_AST = null;
tmp1240_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1240_AST);
match(KW_FLOAT);
vartype = VAR_FLOAT;
break;
}
case KW_LONG:
{
Aast tmp1241_AST = null;
tmp1241_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1241_AST);
match(KW_LONG);
vartype = VAR_LONG;
break;
}
case KW_SHORT:
{
Aast tmp1242_AST = null;
tmp1242_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1242_AST);
match(KW_SHORT);
vartype = VAR_SHORT;
break;
}
case KW_UNS_LONG:
{
Aast tmp1243_AST = null;
tmp1243_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1243_AST);
match(KW_UNS_LONG);
vartype = VAR_ULONG;
break;
}
case KW_UNS_SHRT:
{
Aast tmp1244_AST = null;
tmp1244_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1244_AST);
match(KW_UNS_SHRT);
vartype = VAR_USHORT;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
if ((LA(1)==KW_CLASS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLASS);
hide(cl);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
user_defined_type_name();
nam_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
vartype = VAR_CLASS;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if (varName != null)
{
String cls = (nam_AST == null) ? null : (String) nam_AST.getAnnotation("qualified");
// here is where we enable the variable lookup for all subsequent
// code in this scope, note that Progress only seems to ever have
// 2 levels of scope: the external proc and any internal proc/
// trigger defs, since you can only define shared or global shared
// vars in the external proc scope, we should *not* need to
// explicitly add vars to the global scope since adding to the
// current scope should be equivalent
Variable var = sym.addLocalVariable(varName, vartype, cls);
if (nam_AST != null && nam_AST.isAnnotation("dotnet-array"))
{
var.setDotNetArray(true);
}
if (nam_AST != null && nam_AST.isAnnotation("generic-type-parameter"))
{
var.setGenericType((String) nam_AST.getAnnotation("generic-type-parameter"));
}
if (nam_AST != null && nam_AST.isAnnotation("generic-type-is-primitive"))
{
var.setGenericPrimitive((boolean) nam_AST.getAnnotation("generic-type-is-primitive"));
}
}
var_type_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = var_type_AST;
}
/**
* Matches <code>VALIDATE</code> or <code>USE-INDEX</code> keywords and (in
* the second case) the following index name plus optional
* <code>AS PRIMARY</code> construct. Used by the {@link #like_clause} on
* behalf of the {@link #def_temp_table_stmt} rule.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Separated to properly build the AST.
*
* @param table
* The temp-table object that is being modified.
*/
public final void temp_table_use_index(
Object table
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast temp_table_use_index_AST = null;
Aast u_AST = null;
Token as = null;
Aast as_AST = null;
try { // for error handling
boolean primary = false;
use_index_clause();
u_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_AS) && (LA(2)==KW_PRIMARY) && (_tokenSet_3.member(LA(3)))) {
as = LT(1);
as_AST = (Aast)astFactory.create(as);
match(KW_AS);
hide(as);
Aast tmp1245_AST = null;
tmp1245_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1245_AST);
match(KW_PRIMARY);
primary = true;
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
Aast child = (Aast) u_AST.getFirstChild();
sym.addIndexFrom(table, u_AST, child.getText(), primary);
temp_table_use_index_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = temp_table_use_index_AST;
}
/**
* Matches the <code>IMAGE-SIZE, IMAGE-SIZE-CHARS and IMAGE-SIZE-PIXELS</code>
* keywords and the required following width and height. Used by
* {@link #image_phrase} and the subtree is rooted by the keyword (which is
* the reason for using a separate rule for something so simple).
*/
public final void image_size_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast image_size_clause_AST = null;
Token by = null;
Aast by_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_IMG_SZ:
{
Aast tmp1246_AST = null;
tmp1246_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1246_AST);
match(KW_IMG_SZ);
break;
}
case KW_IMG_SZ_C:
{
Aast tmp1247_AST = null;
tmp1247_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1247_AST);
match(KW_IMG_SZ_C);
break;
}
case KW_IMG_SZ_P:
{
Aast tmp1248_AST = null;
tmp1248_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1248_AST);
match(KW_IMG_SZ_P);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
by = LT(1);
by_AST = (Aast)astFactory.create(by);
match(KW_BY);
hide(by);
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
image_size_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = image_size_clause_AST;
}
/**
* Matches the <code>FROM</code> keyword and the required following
* coordinates (x y or col row). Used by the {@link #image_phrase} rule and
* the subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void from_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast from_clause_AST = null;
try { // for error handling
Aast tmp1249_AST = null;
tmp1249_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1249_AST);
match(KW_FROM);
location_spec();
astFactory.addASTChild(currentAST, returnAST);
location_spec();
astFactory.addASTChild(currentAST, returnAST);
from_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = from_clause_AST;
}
/**
* This rule implements the column/row/x/y coordinate processing for the
* <code>AT phrase</code> ({@link #at_phrase}).
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void location_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast location_spec_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_COLUMNS:
case KW_COL:
case KW_ROW:
case KW_X:
case KW_Y:
{
{
switch ( LA(1)) {
case KW_COL:
{
Aast tmp1250_AST = null;
tmp1250_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1250_AST);
match(KW_COL);
break;
}
case KW_COLUMNS:
{
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_COLUMNS);
c_AST.setType(KW_COL);
break;
}
case KW_ROW:
{
Aast tmp1251_AST = null;
tmp1251_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1251_AST);
match(KW_ROW);
break;
}
case KW_X:
{
Aast tmp1252_AST = null;
tmp1252_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1252_AST);
match(KW_X);
break;
}
case KW_Y:
{
Aast tmp1253_AST = null;
tmp1253_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1253_AST);
match(KW_Y);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_COL_OF:
case KW_ROW_OF:
case KW_X_OF:
case KW_Y_OF:
{
{
switch ( LA(1)) {
case KW_COL_OF:
{
Aast tmp1254_AST = null;
tmp1254_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1254_AST);
match(KW_COL_OF);
break;
}
case KW_ROW_OF:
{
Aast tmp1255_AST = null;
tmp1255_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1255_AST);
match(KW_ROW_OF);
break;
}
case KW_X_OF:
{
Aast tmp1256_AST = null;
tmp1256_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1256_AST);
match(KW_X_OF);
break;
}
case KW_Y_OF:
{
Aast tmp1257_AST = null;
tmp1257_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1257_AST);
match(KW_Y_OF);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
ref_point();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
location_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = location_spec_AST;
}
/**
* Implements the the <code>UNDO</code> action and the optional following
* label references. This is done to improve the tree build. This is only
* called by {@link #on_event_phrase}.
* <p>
* Of particular interest is that this rule implements references to labels
* (see {@link #label_reference}) and to a common form of <code>return</code>
* keyword processing (see {@link #return_core} which is also accessed from
* the <code>RETURN</code> statement rule {@link #return_stmt}).
* <p>
* Note that the use of expressions in the calling rules creates ambiguity
* with the use of the label_reference. This rule is unambiguous in practice.
* For this reason, ambiguity warnings have been disabled.
*/
public final void undo_basic() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast undo_basic_AST = null;
try { // for error handling
Aast tmp1258_AST = null;
tmp1258_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1258_AST);
match(KW_UNDO);
label_reference();
astFactory.addASTChild(currentAST, returnAST);
undo_basic_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_101);
}
returnAST = undo_basic_AST;
}
/**
* Implements the shared core logic for <code>UNDO</code> (see
* {@link #undo_stmt}) and the {@link #on_event_phrase}.
*/
public final void undo_core() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast undo_core_AST = null;
try { // for error handling
comma();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_LEAVE:
case KW_NEXT:
case KW_RETRY:
{
other_on_event_actions();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_RETURN:
{
return_core();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
undo_core_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = undo_core_AST;
}
/**
* Matches the <code>KW_THROW</code> with a following {@link #expr} which
* will be a child node. Used by the {@link #undo_stmt}.
*/
public final void throw_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast throw_clause_AST = null;
try { // for error handling
comma();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp1259_AST = null;
tmp1259_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1259_AST);
match(KW_THROW);
expr();
astFactory.addASTChild(currentAST, returnAST);
throw_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = throw_clause_AST;
}
/**
* Implements the other event actions and the optional following label
* references. This is done to improve the tree build.
* <p>
* Of particular interest is that this rule implements references to labels
* (see {@link #label_reference}) and to a common form of <code>return</code>
* keyword processing (see {@link #return_core} which is also accessed from
* the <code>RETURN</code> statement rule {@link #return_stmt}).
* <p>
* Note that the use of expressions in the calling rules creates ambiguity
* with the use of the label_reference. This rule is unambiguous in practice.
* For this reason, ambiguity warnings have been disabled.
*/
public final void other_on_event_actions() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast other_on_event_actions_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_LEAVE:
{
Aast tmp1260_AST = null;
tmp1260_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1260_AST);
match(KW_LEAVE);
break;
}
case KW_NEXT:
{
Aast tmp1261_AST = null;
tmp1261_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1261_AST);
match(KW_NEXT);
break;
}
case KW_RETRY:
{
Aast tmp1262_AST = null;
tmp1262_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1262_AST);
match(KW_RETRY);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
label_reference();
astFactory.addASTChild(currentAST, returnAST);
other_on_event_actions_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = other_on_event_actions_AST;
}
/**
* Matches the Progress <code>RETURN</code> keyword and builds the
* resulting AST. This is used in multiple locations including the
* {@link #return_stmt} and the {@link #on_event_phrase}.
*/
public final void return_core() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast return_core_AST = null;
try { // for error handling
Aast tmp1263_AST = null;
tmp1263_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1263_AST);
match(KW_RETURN);
{
if ((LA(1)==KW_ERROR) && (_tokenSet_147.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1264_AST = null;
tmp1264_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1264_AST);
match(KW_ERROR);
}
else if ((LA(1)==KW_NO_APPLY) && (_tokenSet_147.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1265_AST = null;
tmp1265_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1265_AST);
match(KW_NO_APPLY);
}
else if ((_tokenSet_147.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( !isValidBlockHeaderOrQueryKeyword(false) )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_144.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
return_core_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_144);
}
returnAST = return_core_AST;
}
/**
* Matches the <code>CACHE-SIZE</code> keyword and the required following
* integer literal.
* <p>
* Used by {@link #query_tuning_phrase} and the subtree is rooted by the
* keyword (which is the reason for using a separate rule for something so
* simple).
*/
public final void query_tuning_cache_size() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast query_tuning_cache_size_AST = null;
try { // for error handling
Aast tmp1266_AST = null;
tmp1266_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1266_AST);
match(KW_CACHE_SZ);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_BYTE:
{
Aast tmp1267_AST = null;
tmp1267_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1267_AST);
match(KW_BYTE);
break;
}
case KW_ROW:
{
Aast tmp1268_AST = null;
tmp1268_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1268_AST);
match(KW_ROW);
break;
}
case KW_ARR_MSG:
case KW_BIND_WH:
case KW_CACHE_SZ:
case KW_DEBUG:
case KW_HINT:
case KW_IDX_HINT:
case KW_JOIN_BY:
case KW_LOOKAHD:
case KW_NO_ARMSG:
case KW_NO_BIND:
case KW_NO_DEBUG:
case KW_NO_IDX_H:
case KW_NO_JOIN:
case KW_NO_LOOKA:
case KW_NO_SEP_C:
case KW_ORD_JOIN:
case KW_REV_FROM:
case KW_SEP_CONN:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
query_tuning_cache_size_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_146);
}
returnAST = query_tuning_cache_size_AST;
}
/**
* Matches the <code>DEBUG</code> keyword and the optional following
* qualifier keyword (<code>SQL or EXTENDED</code>).
* <p>
* Used by {@link #query_tuning_phrase} and the subtree is rooted by the
* keyword (which is the reason for using a separate rule for something so
* simple).
*/
public final void query_tuning_debug() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast query_tuning_debug_AST = null;
try { // for error handling
Aast tmp1269_AST = null;
tmp1269_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1269_AST);
match(KW_DEBUG);
{
switch ( LA(1)) {
case KW_SQL:
{
Aast tmp1270_AST = null;
tmp1270_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1270_AST);
match(KW_SQL);
break;
}
case KW_EXTENDED:
{
extended_diag_option();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_ARR_MSG:
case KW_BIND_WH:
case KW_CACHE_SZ:
case KW_DEBUG:
case KW_HINT:
case KW_IDX_HINT:
case KW_JOIN_BY:
case KW_LOOKAHD:
case KW_NO_ARMSG:
case KW_NO_BIND:
case KW_NO_DEBUG:
case KW_NO_IDX_H:
case KW_NO_JOIN:
case KW_NO_LOOKA:
case KW_NO_SEP_C:
case KW_ORD_JOIN:
case KW_REV_FROM:
case KW_SEP_CONN:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
query_tuning_debug_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_146);
}
returnAST = query_tuning_debug_AST;
}
/**
* Matches the <code>HINT "hint_text"</code> syntax used in the {@link #query_tuning_phrase}. The result
* will be rooted at KW_HINT and there will be a STRING child. The string is not documented but was found
* in customer code.
*/
public final void query_tuning_hint() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast query_tuning_hint_AST = null;
try { // for error handling
Aast tmp1271_AST = null;
tmp1271_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1271_AST);
match(KW_HINT);
Aast tmp1272_AST = null;
tmp1272_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1272_AST);
match(STRING);
query_tuning_hint_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_146);
}
returnAST = query_tuning_hint_AST;
}
/**
* Matches the <code>EXTENDED</code> keyword and the optional following
* qualifier keywords <code>CURSOR, DATA-BIND, PERFORMANCE or VERBOSE</code>.
* <p>
* Used by {@link #query_tuning_debug} and the subtree is rooted by the
* keyword <code>KW_EXTENDED</code> (which is the reason for using a separate
* rule for something so simple).
*/
public final void extended_diag_option() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast extended_diag_option_AST = null;
try { // for error handling
Aast tmp1273_AST = null;
tmp1273_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1273_AST);
match(KW_EXTENDED);
{
switch ( LA(1)) {
case KW_CURSOR:
{
Aast tmp1274_AST = null;
tmp1274_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1274_AST);
match(KW_CURSOR);
break;
}
case KW_DATA_BND:
{
Aast tmp1275_AST = null;
tmp1275_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1275_AST);
match(KW_DATA_BND);
break;
}
case KW_PERF:
{
Aast tmp1276_AST = null;
tmp1276_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1276_AST);
match(KW_PERF);
break;
}
case KW_VERBOSE:
{
Aast tmp1277_AST = null;
tmp1277_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1277_AST);
match(KW_VERBOSE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
extended_diag_option_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_146);
}
returnAST = extended_diag_option_AST;
}
/**
* Matches the <code>OUTER-JOIN</code> keyword and the optional prefix keyword
* <code>LEFT</code> which are used to specify an outer join or left outer
* join. The <code>LEFT</code> token (if it exists) is made a child of
* <code>OUTER-JOIN</code>.
* <p>
* Used by {@link #record_phrase} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void join_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast join_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_LEFT:
{
Aast tmp1278_AST = null;
tmp1278_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1278_AST);
match(KW_LEFT);
break;
}
case KW_OUT_JOIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp1279_AST = null;
tmp1279_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1279_AST);
match(KW_OUT_JOIN);
join_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_148);
}
returnAST = join_clause_AST;
}
/**
* Matches the <code>OF</code> keyword and the required following record
* which is used to specify the table to join on.
* <p>
* Used by {@link #record_phrase} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void of_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast of_clause_AST = null;
try { // for error handling
// if more than one record phrase, can't use
sym.endIndexFieldSearch();
NameNode nothing = null;
Aast tmp1280_AST = null;
tmp1280_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1280_AST);
match(KW_OF);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
of_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_148);
}
returnAST = of_clause_AST;
}
/**
* Matches the <code>USE-INDEX</code> keyword and the required following
* index. The index is matched as a valid user-defined symbol using the
* {@link #symbol} rule, however the result's token type is rewritten to be
* <code>INDEX</code>.
* <p>
* Used by {@link #record_phrase} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void use_index_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast use_index_clause_AST = null;
Aast s_AST = null;
try { // for error handling
Aast tmp1281_AST = null;
tmp1281_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1281_AST);
match(KW_USE_IDX);
any_non_reserved_symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
s_AST.setType(INDEX);
use_index_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = use_index_clause_AST;
}
/**
* Matches the <code>USING</code> keyword and the required following list
* of {@link #lvalue} (fields) and optional matching frames.
* <p>
* Each field can be optionally prefaced with the <code>INPUT</code> keyword
* which seems to have no effect (it is silently dropped). This is an
* undocumented feature of Progress. This parser drops this keyword if it
* is found.
* <p>
* Used by {@link #record_phrase} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void using_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast using_clause_AST = null;
Token in = null;
Aast in_AST = null;
Token an = null;
Aast an_AST = null;
Token in2 = null;
Aast in2_AST = null;
try { // for error handling
Aast tmp1282_AST = null;
tmp1282_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1282_AST);
match(KW_USING);
{
if ((LA(1)==KW_INPUT)) {
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_INPUT);
hide(in);
}
else if ((_tokenSet_64.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_FRAME) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
frame_reference(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1479:
do {
if ((LA(1)==KW_AND) && (_tokenSet_150.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
an = LT(1);
an_AST = (Aast)astFactory.create(an);
match(KW_AND);
hide(an);
{
if ((LA(1)==KW_INPUT)) {
in2 = LT(1);
in2_AST = (Aast)astFactory.create(in2);
match(KW_INPUT);
hide(in2);
}
else if ((_tokenSet_64.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_FRAME) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
frame_reference(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1479;
}
} while (true);
}
using_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_148);
}
returnAST = using_clause_AST;
}
/**
* Matches a database name token that can be a string, a character expression
* that is evaluated via the <code>VALUE( expr )</code> construct, or it
* can be a symbol that represents a physical filename or a logical database
* name. These last two options are differentiated by a boolean passed from
* the caller. Used by {@link #connect_stmt}, {@link #create_alias_stmt}
* and {@link #delete_alias_stmt} rules.
*
* @param physical
* If true, the name could be a physical filename, otherwise it is
* a logical database name.
*/
public final void database_name(
boolean physical
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast database_name_AST = null;
Aast s_AST = null;
try { // for error handling
// DOT and EOF are hard coded in the worker routine
int[] exclude = new int[]
{
LPARENS,
RPARENS
};
{
if ((LA(1)==STRING) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1283_AST = null;
tmp1283_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1283_AST);
match(STRING);
}
else if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
filename(exclude);
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (!physical)
{
// convert unquoted database name to a quoted string
saveAndReplaceTypeAndText(s_AST, STRING, "\"" + s_AST.getText() + "\"");
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
database_name_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_28);
}
returnAST = database_name_AST;
}
/**
* Matches any token except <code>NO-ERROR or DOT</code>. In the
* {@link #connect_stmt}, database connect options are provided which can
* conform to any arbitrary syntax. The options end with either of the
* above tokens.
* <p>
* This rule is nasty because it has to match a list of any kind of token.
* This is inherently ambiguous, and made worse by the loop. ANTLR
* detects ambiguity but the semantic predicate does resolve it. As such
* warnings have been disabled.
*/
public final void connect_options() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast connect_options_AST = null;
Aast v_AST = null;
Token t = null;
Aast t_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(CONNECT_OPTIONS,"options"));
// DOT and EOF are hard coded in the worker routine
int[] exclude = new int[]
{
KW_VALUE,
KW_NO_ERROR
};
mergeUntilWS(exclude);
{
_loop1459:
do {
if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
v_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
mergeUntilWS(exclude);
}
else if ((((LA(1) >= DOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( (LA(1) != KW_NO_ERROR && LA(1) != DOT) )) {
t = LT(1);
t_AST = (Aast)astFactory.create(t);
astFactory.addASTChild(currentAST, t_AST);
matchNot(EOF);
mergeUntilWS(exclude);
t_AST.setType(CONNECT_TEXT);
}
else {
break _loop1459;
}
} while (true);
}
connect_options_AST = (Aast)currentAST.root;
if (connect_options_AST.getNumberOfChildren() == 0) connect_options_AST = null;
currentAST.root = connect_options_AST;
currentAST.child = connect_options_AST!=null &&connect_options_AST.getFirstChild()!=null ?
connect_options_AST.getFirstChild() : connect_options_AST;
currentAST.advanceChildToEnd();
connect_options_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = connect_options_AST;
}
/**
* Matches a <code>CURRENT or COMPLETE</code> keywords and the following
* {@link #database_name} or {@link #value} rule references.
* <p>
* Used by {@link #save_cache_stmt}.
*/
public final void current_or_complete_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast current_or_complete_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_CURRENT:
{
Aast tmp1284_AST = null;
tmp1284_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1284_AST);
match(KW_CURRENT);
break;
}
case KW_COMPLETE:
{
Aast tmp1285_AST = null;
tmp1285_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1285_AST);
match(KW_COMPLETE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
database_name(false);
astFactory.addASTChild(currentAST, returnAST);
current_or_complete_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_188);
}
returnAST = current_or_complete_clause_AST;
}
/**
* Matches a <code>FOR or PRESELECT</code> keyword and the following required
* {@link #each_first_last_spec} of the {@link #open_query_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void for_or_preselect_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_or_preselect_clause_AST = null;
Token f = null;
Aast f_AST = null;
Token p = null;
Aast p_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_FOR:
{
f = LT(1);
f_AST = (Aast)astFactory.create(f);
astFactory.makeASTRoot(currentAST, f_AST);
match(KW_FOR);
break;
}
case KW_PRESEL:
{
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(KW_PRESEL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
each_first_last_spec(false, false);
astFactory.addASTChild(currentAST, returnAST);
for_or_preselect_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_210);
}
returnAST = for_or_preselect_clause_AST;
}
/**
* Matches a <code>MAX-ROWS</code> keyword and the following numeric expression of the
* {@link #open_query_stmt}. The Progress documentation is silent on whether the following
* expression is required to be a constant. Customer code has shown that this is a full
* expression.
* <p>
* This is only separated to simplify the AST build.
*/
public final void max_rows_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast max_rows_clause_AST = null;
try { // for error handling
Aast tmp1286_AST = null;
tmp1286_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1286_AST);
match(KW_MAX_ROWS);
expr();
astFactory.addASTChild(currentAST, returnAST);
max_rows_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_210);
}
returnAST = max_rows_clause_AST;
}
/**
* Matches the <code>TO RECID, TO ROWID or TO ROW</code> keywords and the
* following required expression of type <code>RECID, ROWID</code> or integer
* (in the case of a <code>TO ROW</code>). Calls {@link #expr}.
* <p>
* Used in the {@link #reposition_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void to_recid_or_rowid_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast to_recid_or_rowid_clause_AST = null;
try { // for error handling
Aast tmp1287_AST = null;
tmp1287_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1287_AST);
match(KW_TO);
{
switch ( LA(1)) {
case KW_RECID:
{
Aast tmp1288_AST = null;
tmp1288_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1288_AST);
match(KW_RECID);
break;
}
case KW_ROWID:
{
Aast tmp1289_AST = null;
tmp1289_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1289_AST);
match(KW_ROWID);
break;
}
case KW_ROW:
{
Aast tmp1290_AST = null;
tmp1290_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1290_AST);
match(KW_ROW);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1223:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1223;
}
} while (true);
}
to_recid_or_rowid_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = to_recid_or_rowid_clause_AST;
}
/**
* Matches a <code>FORWARDS or BACKWARDS</code> keyword and the
* following required {@link #expr}. Used in the {@link #reposition_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void reposition_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast reposition_spec_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_FORWARD:
{
Aast tmp1291_AST = null;
tmp1291_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1291_AST);
match(KW_FORWARD);
break;
}
case KW_BACKWARD:
{
Aast tmp1292_AST = null;
tmp1292_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1292_AST);
match(KW_BACKWARD);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
reposition_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = reposition_spec_AST;
}
/**
* Matches a <code>FROM</code> keyword and the following {@link #expr}
* of the {@link #create_database_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void from_database_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast from_database_clause_AST = null;
try { // for error handling
Aast tmp1293_AST = null;
tmp1293_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1293_AST);
match(KW_FROM);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_NEW_INST:
{
Aast tmp1294_AST = null;
tmp1294_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1294_AST);
match(KW_NEW_INST);
break;
}
case DOT:
case KW_NO_ERROR:
case KW_REPLACE:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
from_database_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_211);
}
returnAST = from_database_clause_AST;
}
/**
* This is a convenience method that matches {@link #chained_object_members} except a validating
* semantic predicate is used to throw an exception if the data type of the variable or field is
* not <code>HANDLE</code>. The most common case is a simple <code>lvalue</code> usage, but it
* is possible to match a handle attribute ot qualified object member.
* <p>
* It is an open question as to whether this rule should also have references to
* <code>FUNC_HANDLE</code> or <code>METH_HANDLE</code>. Generally the answer would be NO if
* the caller would need to assign to this handle and YES if the caller would just use the
* handle. Most references to this rule are in create/delete rules where this rule is safe. The
* {@link #from_handle_clause} does seem to use this differently. These two types are
* provisionally supported for now until they can be checked in real code.
* <p>
* To test for <code>ATTR_HANDLE</code>, <code>ATTR_COM_HANDLE</code>, <code>METH_HANDLE</code>
* and <code>METH_COM_HANDLE</code>, a simple check for a <code>COLON</code> operator or
* <code>OBJECT_INVOCATION</code> is done. This test should probably be made more thorough.
* <p>
* Used in {@link #create_query_stmt} and in other locations.
*/
public final void handle() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast handle_AST = null;
Aast h_AST = null;
try { // for error handling
chained_object_members();
h_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (!(
h_AST.getType() == VAR_HANDLE ||
h_AST.getType() == FIELD_HANDLE ||
h_AST.getType() == FUNC_HANDLE ||
h_AST.getType() == COLON ||
h_AST.getType() == OBJECT_INVOCATION ||
h_AST.getType() == OO_METH_HANDLE ||
h_AST.getType() == SYS_HANDLE ||
h_AST.getType() == VAR_COM_HANDLE ||
h_AST.getType() == FIELD_COM_HANDLE ||
h_AST.getType() == FUNC_COM_HANDLE ||
h_AST.getType() == OO_METH_COM_HANDLE
))
throw new SemanticException("\n h_AST.getType() == VAR_HANDLE ||\n h_AST.getType() == FIELD_HANDLE ||\n h_AST.getType() == FUNC_HANDLE ||\n h_AST.getType() == COLON ||\n h_AST.getType() == OBJECT_INVOCATION ||\n h_AST.getType() == OO_METH_HANDLE ||\n h_AST.getType() == SYS_HANDLE ||\n h_AST.getType() == VAR_COM_HANDLE ||\n h_AST.getType() == FIELD_COM_HANDLE ||\n h_AST.getType() == FUNC_COM_HANDLE ||\n h_AST.getType() == OO_METH_COM_HANDLE\n ");
handle_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_147);
}
returnAST = handle_AST;
}
/**
* Matches the <code>IN WIDGET-POOL</code> keywords and the required following
* pool name as a character expression (see {@link #expr}).
* <p>
* Used by {@link #create_query_stmt}, {@link #create_temp_table_stmt},
* {@link #create_buffer_stmt}, {@link #create_widget_or_object_stmt} and
* {@link #create_browse_stmt}.
* <p>
* This is a separate rule to centralize logic and build the AST properly.
*/
public final void in_widget_pool_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_widget_pool_clause_AST = null;
Token i = null;
Aast i_AST = null;
Token wp = null;
Aast wp_AST = null;
try { // for error handling
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.makeASTRoot(currentAST, i_AST);
match(KW_IN);
i_AST.setType(IN_WIDGET_POOL);
wp = LT(1);
wp_AST = (Aast)astFactory.create(wp);
match(KW_WID_POOL);
hide(wp);
expr();
astFactory.addASTChild(currentAST, returnAST);
in_widget_pool_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_212);
}
returnAST = in_widget_pool_clause_AST;
}
/**
* Matches a <code>FOR TABLE</code> construct and the following {@link #expr}
* of the {@link #create_buffer_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void for_table_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast for_table_clause_AST = null;
try { // for error handling
Aast tmp1295_AST = null;
tmp1295_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1295_AST);
match(KW_FOR);
Aast tmp1296_AST = null;
tmp1296_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1296_AST);
match(KW_TABLE);
expr();
astFactory.addASTChild(currentAST, returnAST);
for_table_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_213);
}
returnAST = for_table_clause_AST;
}
/**
* Matches a <code>BUFFER-NAME</code> keyword and the following {@link #expr}
* of the {@link #create_buffer_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void buffer_name_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast buffer_name_clause_AST = null;
try { // for error handling
Aast tmp1297_AST = null;
tmp1297_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1297_AST);
match(KW_BUF_NAME);
expr();
astFactory.addASTChild(currentAST, returnAST);
buffer_name_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_213);
}
returnAST = buffer_name_clause_AST;
}
/**
* Matches the <code>EXCEPT or USING</code> keywords and the required list
* of following {@link #lvalue}.
* <p>
* Used by {@link #buffer_compare_or_copy_stmt}.
*/
public final void buffer_modification_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast buffer_modification_list_AST = null;
Aast l_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_EXCEPT:
{
Aast tmp1298_AST = null;
tmp1298_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1298_AST);
match(KW_EXCEPT);
break;
}
case KW_USING:
{
Aast tmp1299_AST = null;
tmp1299_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1299_AST);
match(KW_USING);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop1260:
do {
if ((_tokenSet_64.member(LA(1)))) {
boolean savePreferFields = preferFields;
preferFields = true;
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
preferFields = false;
if (l_AST.getType() < BEGIN_FIELDTYPES || l_AST.getType() > END_FIELDTYPES)
{
LOG.log(Level.SEVERE, "'" + l_AST.getText() + "' is not a field at " +
l_AST.getLine() + ":" + l_AST.getColumn());
}
}
else {
break _loop1260;
}
} while (true);
}
buffer_modification_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_188);
}
returnAST = buffer_modification_list_AST;
}
/**
* Matches the <code>TO</code> keyword and the following {@link #record}.
* <p>
* Used by {@link #buffer_compare_or_copy_stmt}.
*/
public final void to_target() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast to_target_AST = null;
try { // for error handling
NameNode nothing = null;
Aast tmp1300_AST = null;
tmp1300_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1300_AST);
match(KW_TO);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
to_target_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_214);
}
returnAST = to_target_AST;
}
/**
* Matches the <code>SAVE</code> keyword (and optional <code>RESULT IN</code>)
* and the following {@link #lvalue}.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Used by {@link #buffer_compare_or_copy_stmt} (only for the compare form).
*/
public final void save_result_in() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast save_result_in_AST = null;
try { // for error handling
Aast tmp1301_AST = null;
tmp1301_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1301_AST);
match(KW_SAVE);
{
if ((LA(1)==KW_RESULT) && (LA(2)==KW_IN) && (_tokenSet_64.member(LA(3)))) {
Aast tmp1302_AST = null;
tmp1302_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1302_AST);
match(KW_RESULT);
Aast tmp1303_AST = null;
tmp1303_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1303_AST);
match(KW_IN);
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
lvalue();
astFactory.addASTChild(currentAST, returnAST);
save_result_in_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_214);
}
returnAST = save_result_in_AST;
}
/**
* Matches the <code>COMPARES</code> keyword (and optional
* <code>EXPLICIT</code> prefix), an optional <code>NO-ERROR</code> and
* the {@link #compares_when_block}.
* <p>
* Used by {@link #buffer_compare_or_copy_stmt} (only for the compare form).
*/
public final void explicit_compares() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast explicit_compares_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_COMPARES:
case KW_EXPLICIT:
{
{
switch ( LA(1)) {
case KW_EXPLICIT:
{
Aast tmp1304_AST = null;
tmp1304_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1304_AST);
match(KW_EXPLICIT);
break;
}
case KW_COMPARES:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp1305_AST = null;
tmp1305_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1305_AST);
match(KW_COMPARES);
break;
}
case KW_NO_ERROR:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_NO_ERROR:
{
Aast tmp1306_AST = null;
tmp1306_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1306_AST);
match(KW_NO_ERROR);
break;
}
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
compares_when_block();
astFactory.addASTChild(currentAST, returnAST);
explicit_compares_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_214);
}
returnAST = explicit_compares_AST;
}
/**
* Matches the <code>ASSIGN</code> keyword and a list of space delimited
* assignment expressions. This is similar to but more simplified version
* of {@link #assign_stmt}.
* <p>
* Used by {@link #buffer_compare_or_copy_stmt} only in the copy form.
* <p>
* Bogus ANTLR ambiguity warnings are disabled.
*/
public final void sub_assign_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast sub_assign_clause_AST = null;
try { // for error handling
Aast tmp1307_AST = null;
tmp1307_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1307_AST);
match(KW_ASSIGN);
{
int _cnt1274=0;
_loop1274:
do {
if (((_tokenSet_85.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_NO_ERROR && LA(1) != KW_NO_LOBS )) {
assign();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_WHEN) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
simple_when_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_144.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
if ( _cnt1274>=1 ) { break _loop1274; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1274++;
} while (true);
}
sub_assign_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_214);
}
returnAST = sub_assign_clause_AST;
}
/**
* Matches the <code>COLON</code> token followed by one or more
* {@link #when_clause} constructs and terminated by an <code>END</code>
* keyword.
* <p>
* Used by {@link #explicit_compares}.
*/
public final void compares_when_block() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast compares_when_block_AST = null;
Token en = null;
Aast en_AST = null;
Token co = null;
Aast co_AST = null;
try { // for error handling
Aast tmp1308_AST = null;
tmp1308_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1308_AST);
match(COLON);
{
_loop1270:
do {
if ((LA(1)==KW_WHEN)) {
when_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1270;
}
} while (true);
}
en = LT(1);
en_AST = (Aast)astFactory.create(en);
match(KW_END);
hide(en);
co = LT(1);
co_AST = (Aast)astFactory.create(co);
match(KW_COMPARES);
hide(co);
compares_when_block_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_214);
}
returnAST = compares_when_block_AST;
}
/**
* Matches the <code>CONNECT</code> option for the {@link #create_widget_or_object_stmt}
* with than optional <code>TO expression</code>.
*/
public final void com_connect_option() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast com_connect_option_AST = null;
Token to = null;
Aast to_AST = null;
try { // for error handling
Aast tmp1309_AST = null;
tmp1309_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1309_AST);
match(KW_CONN);
{
switch ( LA(1)) {
case KW_TO:
{
to = LT(1);
to_AST = (Aast)astFactory.create(to);
match(KW_TO);
hide(to);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_ASSIGN:
case KW_IN:
case KW_NO_ERROR:
case KW_TRIGGERS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
com_connect_option_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_117);
}
returnAST = com_connect_option_AST;
}
/**
* Matches the <code>ASSIGN</code> keyword and a list of space delimited
* <code>ATTRIBUTE</code> assignment expressions. This is similar to but
* a more simplified version of {@link #assign_stmt}. Please note that
* this is a special form for use in the {@link #create_widget_or_object_stmt} AND
* that the use of the {@link #attribute_assign} rule for the core logic
* especially since that use is in a loop) MUST be protected with a
* semantic predicate to ensure that the rule reference doesn't consume
* a possible following <code>TRIGGERS</code> keyword (since the leftmost
* token of the called rule can include ANY reserved or other symbol.
* <p>
* Also used in the {@link #create_browse_stmt} and {@link #create_server_stmt}.
* <p>
* Bogus ANTLR ambiguity warnings are disabled.
*/
public final void attribute_assign_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast attribute_assign_clause_AST = null;
try { // for error handling
Aast tmp1310_AST = null;
tmp1310_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1310_AST);
match(KW_ASSIGN);
{
int _cnt1291=0;
_loop1291:
do {
if (((_tokenSet_90.member(LA(1))) && (LA(2)==EQUALS||LA(2)==LBRACKET||LA(2)==LPARENS) && (_tokenSet_215.member(LA(3))))&&( LA(1) != KW_TRIGGERS )) {
attribute_assign();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt1291>=1 ) { break _loop1291; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1291++;
} while (true);
}
attribute_assign_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_216);
}
returnAST = attribute_assign_clause_AST;
}
/**
* Matches an {@link #attribute_or_method}, an <code>EQUALS</code> token (the
* equals sign) and a following {@link #expr}. The token type of the
* <code>EQUALS</code> is changed to <code>ASSIGN</code> and the entire
* construct is rooted on that token. The token type of the first child
* of the <code>ASSIGN</code> node must be an attribute, though this is not
* enforced.
* <p>
* Any use of this rule especially if that use is in a loop) MUST be
* protected with a semantic predicate to ensure that the rule reference
* doesn't consume possible following keywords (since the leftmost
* token of the called rule can include ANY reserved or other symbol.
* <p>
* Used by {@link #attribute_assign_clause}.
*/
public final void attribute_assign() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast attribute_assign_AST = null;
Token eq = null;
Aast eq_AST = null;
try { // for error handling
attribute_or_method();
astFactory.addASTChild(currentAST, returnAST);
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(EQUALS);
eq_AST.setType(ASSIGN);
expr();
astFactory.addASTChild(currentAST, returnAST);
attribute_assign_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_217);
}
returnAST = attribute_assign_AST;
}
/**
* This rule provides generic method and attribute support in a centralized
* manner. This is used from {@link #lvalue}. The result of this rule
* is either an <code>ATTR_*</code> node or a <code>METH_*</code> node
* with method parameters (usually an {@link #expr}) as immediate children.
* <p>
* All method references are resolved to a value between the range of
* <code>BEGIN_METH</code> and <code>END_METH</code> types and all attribute
* references are resolved to a value between the range of
* <code>BEGIN_ATTR</code> and <code>END_ATTR</code> types. A namespace of
* the method and attribute names and associated types is used to resolve
* these values. <b>This namespace is partial at this time and thus it only
* represents a small portion of all possible methods and attributes.</b>
* <p>
* List of possible resulting token types:
* <p>
* <pre>
* 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_RAW
* METH_RECID
* METH_ROWID
* METH_POLY
* METH_VOID
* </pre>
* <p>
* This rule uses a {@link #reserved_or_symbol} to create a "pull" for all
* possible attribute or method names. In the init action, the 2nd token
* is inspected to determine if it is an <code>LPARENS</code> or
* <code>LBRACKET</code> (yes, this is an undocumented "feature"). In either
* of these cases, this is determined to be a method. The optional method
* parameters are then parsed.
* <p>
* Please note that this use of reserved keywords is required since
* attributes and methods can use reserved names.
* <p>
* Some parameters are keywords (e.g. <code>NO-LOCK</code>) rather than
* valid expressions. For this reason, the {@link #reserved_or_symbol} rule
* is the last-ditch alternative for a parameter.
* <p>
* WARNING: starting in Progress v10.x attributes and methods can be chained
* using the <code>COLON</code> operator. This means that this rule will
* recursively call itself to implement such support.
*/
public final void attribute_or_method() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast attribute_or_method_AST = null;
Token lb = null;
Aast lb_AST = null;
Token rb = null;
Aast rb_AST = null;
try { // for error handling
int oldtype = -1;
int current = LA(1);
boolean oldpref = preferWidgets;
// temporarily disable widget preference so the expression will
// parse without widget refs
if (oldpref)
{
preferWidgets = false;
}
if (current < BEGIN_ATTR_METH || current > END_ATTR_METH)
{
// fixup for stupid/unnecessary Progress ambiguity
if (current == KW_WIDTH)
{
current = KW_WIDTH_C;
}
// do a lookup, it better find something!
int newtype = sym.lookupAttributeOrMethod(current);
// save off old type
oldtype = current;
// undocumented keyword synonym
if (oldtype == KW_COLUMNS)
{
oldtype = KW_COL;
}
// handle a fixup due to ambiguity in Progress (it is also an
// ATTR_HANDLE and that is how it is returned from the lookup)
if (current == KW_BUF_FLD)
{
if (LA(2) == LPARENS || LA(2) == LBRACKET)
{
newtype = METH_HANDLE;
}
}
// safety first
if ( newtype != -1 )
{
// set the type
LT(1).setType( newtype );
}
else
{
// unknown method or attribute!
throw new NoViableAltException(LT(1), getFilename());
}
}
boolean possibleLparens = true;
if (LA(1) > BEGIN_ATTR && LA(1) < END_ATTR)
{
// this must include all possible attributes which can receive an argument
// (like BUFFER-VALUE)
possibleLparens = oldtype == KW_BUF_VAL || // buffer-value
oldtype == KW_DATA_SRI || // data-source-rowid
oldtype == KW_GET_B_A || // get-bytes-available
oldtype == KW_GET_SRCB || // get-source-buffer
oldtype == KW_IDX_INFO || // index-information
oldtype == KW_IS_P_SET || // is-parameter-set
oldtype == KW_KEYS || // keys
oldtype == KW_NEXT_RID || // next-rowid
oldtype == KW_REST_RID || // restart-rowid
oldtype == KW_SAVE_WST || // save-where-string
oldtype == KW_STR_VAL || // string-value
oldtype == KW_TOP_NAVQ // top-nav-query
;
}
{
{
switch ( LA(1)) {
case ATTR_CHAR:
{
Aast tmp1311_AST = null;
tmp1311_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1311_AST);
match(ATTR_CHAR);
break;
}
case ATTR_CLASS:
{
Aast tmp1312_AST = null;
tmp1312_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1312_AST);
match(ATTR_CLASS);
break;
}
case ATTR_COM_HANDLE:
{
Aast tmp1313_AST = null;
tmp1313_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1313_AST);
match(ATTR_COM_HANDLE);
break;
}
case ATTR_DATE:
{
Aast tmp1314_AST = null;
tmp1314_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1314_AST);
match(ATTR_DATE);
break;
}
case ATTR_DATETIME:
{
Aast tmp1315_AST = null;
tmp1315_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1315_AST);
match(ATTR_DATETIME);
break;
}
case ATTR_DATETIME_TZ:
{
Aast tmp1316_AST = null;
tmp1316_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1316_AST);
match(ATTR_DATETIME_TZ);
break;
}
case ATTR_DEC:
{
Aast tmp1317_AST = null;
tmp1317_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1317_AST);
match(ATTR_DEC);
break;
}
case ATTR_HANDLE:
{
Aast tmp1318_AST = null;
tmp1318_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1318_AST);
match(ATTR_HANDLE);
break;
}
case ATTR_INT:
{
Aast tmp1319_AST = null;
tmp1319_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1319_AST);
match(ATTR_INT);
break;
}
case ATTR_INT64:
{
Aast tmp1320_AST = null;
tmp1320_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1320_AST);
match(ATTR_INT64);
break;
}
case ATTR_LOGICAL:
{
Aast tmp1321_AST = null;
tmp1321_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1321_AST);
match(ATTR_LOGICAL);
break;
}
case ATTR_LONGCHAR:
{
Aast tmp1322_AST = null;
tmp1322_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1322_AST);
match(ATTR_LONGCHAR);
break;
}
case ATTR_MEMPTR:
{
Aast tmp1323_AST = null;
tmp1323_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1323_AST);
match(ATTR_MEMPTR);
break;
}
case ATTR_RAW:
{
Aast tmp1324_AST = null;
tmp1324_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1324_AST);
match(ATTR_RAW);
break;
}
case ATTR_RECID:
{
Aast tmp1325_AST = null;
tmp1325_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1325_AST);
match(ATTR_RECID);
break;
}
case ATTR_ROWID:
{
Aast tmp1326_AST = null;
tmp1326_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1326_AST);
match(ATTR_ROWID);
break;
}
case ATTR_POLY:
{
Aast tmp1327_AST = null;
tmp1327_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1327_AST);
match(ATTR_POLY);
break;
}
case METH_CHAR:
{
Aast tmp1328_AST = null;
tmp1328_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1328_AST);
match(METH_CHAR);
break;
}
case METH_CLASS:
{
Aast tmp1329_AST = null;
tmp1329_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1329_AST);
match(METH_CLASS);
break;
}
case METH_COM_HANDLE:
{
Aast tmp1330_AST = null;
tmp1330_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1330_AST);
match(METH_COM_HANDLE);
break;
}
case METH_DATE:
{
Aast tmp1331_AST = null;
tmp1331_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1331_AST);
match(METH_DATE);
break;
}
case METH_DATETIME:
{
Aast tmp1332_AST = null;
tmp1332_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1332_AST);
match(METH_DATETIME);
break;
}
case METH_DATETIME_TZ:
{
Aast tmp1333_AST = null;
tmp1333_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1333_AST);
match(METH_DATETIME_TZ);
break;
}
case METH_DEC:
{
Aast tmp1334_AST = null;
tmp1334_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1334_AST);
match(METH_DEC);
break;
}
case METH_HANDLE:
{
Aast tmp1335_AST = null;
tmp1335_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1335_AST);
match(METH_HANDLE);
break;
}
case METH_INT:
{
Aast tmp1336_AST = null;
tmp1336_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1336_AST);
match(METH_INT);
break;
}
case METH_INT64:
{
Aast tmp1337_AST = null;
tmp1337_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1337_AST);
match(METH_INT64);
break;
}
case METH_LOGICAL:
{
Aast tmp1338_AST = null;
tmp1338_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1338_AST);
match(METH_LOGICAL);
break;
}
case METH_LONGCHAR:
{
Aast tmp1339_AST = null;
tmp1339_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1339_AST);
match(METH_LONGCHAR);
break;
}
case METH_MEMPTR:
{
Aast tmp1340_AST = null;
tmp1340_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1340_AST);
match(METH_MEMPTR);
break;
}
case METH_RAW:
{
Aast tmp1341_AST = null;
tmp1341_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1341_AST);
match(METH_RAW);
break;
}
case METH_RECID:
{
Aast tmp1342_AST = null;
tmp1342_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1342_AST);
match(METH_RECID);
break;
}
case METH_ROWID:
{
Aast tmp1343_AST = null;
tmp1343_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1343_AST);
match(METH_ROWID);
break;
}
case METH_POLY:
{
Aast tmp1344_AST = null;
tmp1344_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1344_AST);
match(METH_POLY);
break;
}
case METH_VOID:
{
Aast tmp1345_AST = null;
tmp1345_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1345_AST);
match(METH_VOID);
break;
}
default:
if ((_tokenSet_27.member(LA(1)))) {
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( possibleLparens )) {
{
if ((LA(1)==LBRACKET||LA(1)==LPARENS) && (_tokenSet_215.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case LPARENS:
{
lparens();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case LBRACKET:
{
lb = LT(1);
lb_AST = (Aast)astFactory.create(lb);
match(LBRACKET);
hide(lb);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((_tokenSet_24.member(LA(1)))) {
{
if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_27.member(LA(1))) && (LA(2)==RBRACKET||LA(2)==COMMA||LA(2)==RPARENS) && (_tokenSet_3.member(LA(3)))) {
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1739:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_27.member(LA(1))) && (LA(2)==RBRACKET||LA(2)==COMMA||LA(2)==RPARENS) && (_tokenSet_3.member(LA(3)))) {
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop1739;
}
} while (true);
}
}
else if ((LA(1)==RBRACKET||LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case RPARENS:
{
rparens();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RBRACKET:
{
rb = LT(1);
rb_AST = (Aast)astFactory.create(rb);
match(RBRACKET);
hide(rb);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
attribute_or_method_AST = (Aast)currentAST.root;
// reset back to state at entrance to this method
if (oldpref)
{
preferWidgets = true;
}
int ttype = attribute_or_method_AST.getType();
// store the fully qualified class name for atts/meths that return
// an object reference
if (ttype == ATTR_CLASS || ttype == METH_CLASS)
{
String cls = sym.lookupAttributeOrMethodClass(current);
if (cls == null)
{
String err = String.format("Missing class name for %s!",
attribute_or_method_AST.getDescriptiveTokenText());
throw genExc(err, attribute_or_method_AST);
}
sym.annotateClassRef(cls, attribute_or_method_AST);
}
// save off original type from before token rewriting
if (oldtype != -1)
attribute_or_method_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
attribute_or_method_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = attribute_or_method_AST;
}
/**
* This is a convenience method that matches {@link #lvalue} except a
* validating semantic predicate is used to throw an exception if the
* data type of the variable or field is not a <code>COM-HANDLE</code>.
* <p>
* It is an open question as to whether this rule should also have references
* to <code>FUNC_COM_HANDLE</code>. Generally the answer would
* be NO if the caller would need to assign to this handle and YES if the
* caller would just use the handle. Right now, references to this rule are
* in create/release rules where this rule is safe.
* <p>
* Used in {@link #create_widget_or_object_stmt} and {@link #release_object_stmt}.
*/
public final void com_handle() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast com_handle_AST = null;
Aast h_AST = null;
try { // for error handling
lvalue();
h_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (!(
h_AST.getType() == VAR_COM_HANDLE ||
h_AST.getType() == FIELD_COM_HANDLE ||
(h_AST.getType() == SYS_HANDLE &&
h_AST.getAnnotation("oldtype") != null &&
((Long) h_AST.getAnnotation("oldtype")).intValue() == KW_COM_SELF)
))
throw new SemanticException("\n h_AST.getType() == VAR_COM_HANDLE ||\n h_AST.getType() == FIELD_COM_HANDLE ||\n (h_AST.getType() == SYS_HANDLE &&\n h_AST.getAnnotation(\"oldtype\") != null &&\n ((Long) h_AST.getAnnotation(\"oldtype\")).intValue() == KW_COM_SELF)\n ");
com_handle_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = com_handle_AST;
}
/**
* Matches <code>ITEM</code> clause followed by an {@link #expr}. Used by
* {@link #dde_advise_stmt}, {@link #dde_get_stmt}, {@link #dde_request_stmt}
* and {@link #dde_send_stmt}.
*/
public final void item_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast item_clause_AST = null;
try { // for error handling
Aast tmp1346_AST = null;
tmp1346_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1346_AST);
match(KW_ITEM);
expr();
astFactory.addASTChild(currentAST, returnAST);
item_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_218);
}
returnAST = item_clause_AST;
}
/**
* Matches <code>TIME</code> clause followed by an {@link #expr}. Used by
* {@link #dde_advise_stmt}, {@link #dde_execute_stmt}, {@link #dde_get_stmt},
* {@link #dde_request_stmt} and {@link #dde_send_stmt}.
*/
public final void time_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast time_clause_AST = null;
try { // for error handling
Aast tmp1347_AST = null;
tmp1347_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1347_AST);
match(KW_TIME);
expr();
astFactory.addASTChild(currentAST, returnAST);
time_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = time_clause_AST;
}
/**
* Matches <code>COMMAND</code> clause followed by an {@link #expr}. Used by
* {@link #dde_execute_stmt}.
*/
public final void command_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast command_clause_AST = null;
try { // for error handling
Aast tmp1348_AST = null;
tmp1348_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1348_AST);
match(KW_COMMAND);
expr();
astFactory.addASTChild(currentAST, returnAST);
command_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_218);
}
returnAST = command_clause_AST;
}
/**
* Matches <code>FRAME</code> clause followed by a {@link #handle}.
* Used by {@link #dde_initiate_stmt}.
*/
public final void frame_handle_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast frame_handle_clause_AST = null;
try { // for error handling
Aast tmp1349_AST = null;
tmp1349_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1349_AST);
match(KW_FRAME);
handle();
astFactory.addASTChild(currentAST, returnAST);
frame_handle_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_219);
}
returnAST = frame_handle_clause_AST;
}
/**
* Matches <code>APPLICATION</code> clause followed by an {@link #expr}.
* Used by {@link #dde_initiate_stmt}.
*/
public final void application_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast application_clause_AST = null;
try { // for error handling
Aast tmp1350_AST = null;
tmp1350_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1350_AST);
match(KW_APPL);
expr();
astFactory.addASTChild(currentAST, returnAST);
application_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_220);
}
returnAST = application_clause_AST;
}
/**
* Matches <code>TOPIC</code> clause followed by an {@link #expr}.
* Used by {@link #dde_initiate_stmt}.
*/
public final void topic_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast topic_clause_AST = null;
try { // for error handling
Aast tmp1351_AST = null;
tmp1351_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1351_AST);
match(KW_TOPIC);
expr();
astFactory.addASTChild(currentAST, returnAST);
topic_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = topic_clause_AST;
}
/**
* Matches <code>UPDATE</code> clause followed by an {@link #lvalue}.
* Used by {@link #system_dialog_color_stmt},
* {@link #system_dialog_font_stmt}, {@link #system_dialog_get_file_stmt} and
* {@link #system_dialog_printer_setup_stmt}.
*/
public final void update_logical_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast update_logical_clause_AST = null;
try { // for error handling
Aast tmp1352_AST = null;
tmp1352_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1352_AST);
match(KW_UPDATE);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
update_logical_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_221);
}
returnAST = update_logical_clause_AST;
}
/**
* Matches the <code>IN WINDOW</code> clause followed by a {@link #handle}.
* Used by {@link #system_dialog_color_stmt},
* {@link #system_dialog_font_stmt}, {@link #system_dialog_get_file_stmt} and
* {@link #system_dialog_printer_setup_stmt}.
*/
public final void in_window_handle_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_window_handle_clause_AST = null;
try { // for error handling
Aast tmp1353_AST = null;
tmp1353_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1353_AST);
match(KW_IN);
Aast tmp1354_AST = null;
tmp1354_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1354_AST);
match(KW_WINDOW);
handle();
astFactory.addASTChild(currentAST, returnAST);
in_window_handle_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_221);
}
returnAST = in_window_handle_clause_AST;
}
/**
* Matches the <code>MAX-SIZE or MIN-SIZE</code> clause followed by an
* {@link #expr}. Used by {@link #system_dialog_font_stmt}.
*/
public final void min_max_size_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast min_max_size_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_MAX_SZ:
{
Aast tmp1355_AST = null;
tmp1355_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1355_AST);
match(KW_MAX_SZ);
break;
}
case KW_MIN_SZ:
{
Aast tmp1356_AST = null;
tmp1356_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1356_AST);
match(KW_MIN_SZ);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
min_max_size_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_222);
}
returnAST = min_max_size_clause_AST;
}
/**
* Matches the <code>INITIAL-DIR</code> clause followed by an {@link #expr}.
* Used by {@link #system_dialog_get_file_stmt}.
*/
public final void initial_dir_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast initial_dir_clause_AST = null;
try { // for error handling
Aast tmp1357_AST = null;
tmp1357_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1357_AST);
match(KW_INIT_DIR);
expr();
astFactory.addASTChild(currentAST, returnAST);
initial_dir_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_223);
}
returnAST = initial_dir_clause_AST;
}
/**
* Matches the <code>TITLE</code> clause followed by an {@link #expr}. Used
* by {@link #system_dialog_get_file_stmt}.
*/
public final void title_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast title_clause_AST = null;
try { // for error handling
Aast tmp1358_AST = null;
tmp1358_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1358_AST);
match(KW_TITLE);
expr();
astFactory.addASTChild(currentAST, returnAST);
title_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_224);
}
returnAST = title_clause_AST;
}
/**
* Matches the <code>DEFAULT-EXTENSION</code> clause followed by an
* {@link #expr}. Used by {@link #system_dialog_get_file_stmt}.
*/
public final void default_extension_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast default_extension_clause_AST = null;
try { // for error handling
Aast tmp1359_AST = null;
tmp1359_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1359_AST);
match(KW_DEF_EXTN);
expr();
astFactory.addASTChild(currentAST, returnAST);
default_extension_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_223);
}
returnAST = default_extension_clause_AST;
}
/**
* Matches the <code>FILTERS</code> clause followed by a list of pairs of
* character expressions matched by {@link #filter_spec}. Optionally uses
* {@link #initial_filter_num}. Used by {@link #system_dialog_get_file_stmt}.
*/
public final void filters_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast filters_clause_AST = null;
try { // for error handling
Aast tmp1360_AST = null;
tmp1360_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1360_AST);
match(KW_FILTERS);
filter_spec();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1360:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
filter_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1360;
}
} while (true);
}
{
switch ( LA(1)) {
case KW_INIT_FLT:
{
initial_filter_num();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_TITLE:
case KW_UPDATE:
case KW_ASK_OVER:
case KW_CREAT_TF:
case KW_DEF_EXTN:
case KW_FILTERS:
case KW_INIT_DIR:
case KW_MULTIPLE:
case KW_MUST_EXI:
case KW_RET_2SD:
case KW_SAVE_AS:
case KW_USE_FIL:
case KW_AT_W_BRW:
case KW_UPLOAD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
filters_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_225);
}
returnAST = filters_clause_AST;
}
/**
* Matches AT-WEB-BROWSER option.
*/
public final void at_web_browser_option() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast at_web_browser_option_AST = null;
try { // for error handling
Aast tmp1361_AST = null;
tmp1361_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1361_AST);
match(KW_AT_W_BRW);
{
switch ( LA(1)) {
case KW_UPLOAD:
{
at_web_browser_upload();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_TITLE:
case KW_UPDATE:
case KW_ASK_OVER:
case KW_CREAT_TF:
case KW_DEF_EXTN:
case KW_FILTERS:
case KW_INIT_DIR:
case KW_MULTIPLE:
case KW_MUST_EXI:
case KW_RET_2SD:
case KW_SAVE_AS:
case KW_USE_FIL:
case KW_AT_W_BRW:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
at_web_browser_option_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_223);
}
returnAST = at_web_browser_option_AST;
}
/**
* Matches UPLOAD DIR option.
*/
public final void at_web_browser_upload() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast at_web_browser_upload_AST = null;
try { // for error handling
Aast tmp1362_AST = null;
tmp1362_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1362_AST);
match(KW_UPLOAD);
{
switch ( LA(1)) {
case KW_DIR:
{
match(KW_DIR);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_TITLE:
case KW_UPDATE:
case KW_ASK_OVER:
case KW_CREAT_TF:
case KW_DEF_EXTN:
case KW_FILTERS:
case KW_INIT_DIR:
case KW_MULTIPLE:
case KW_MUST_EXI:
case KW_RET_2SD:
case KW_SAVE_AS:
case KW_USE_FIL:
case KW_AT_W_BRW:
case KW_UPLOAD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
at_web_browser_upload_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_225);
}
returnAST = at_web_browser_upload_AST;
}
/**
* Matches the <code>NUM-COPIES</code> clause followed by an {@link #expr}.
* Used by {@link #system_dialog_printer_setup_stmt}.
*/
public final void num_copies_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast num_copies_clause_AST = null;
try { // for error handling
Aast tmp1364_AST = null;
tmp1364_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1364_AST);
match(KW_NUM_COPY);
expr();
astFactory.addASTChild(currentAST, returnAST);
num_copies_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_226);
}
returnAST = num_copies_clause_AST;
}
/**
* Matches a pair of {@link #expr} and roots both of them at a node of type
* <code>FILTER_SPEC</code>. Used by {@link #filters_clause}.
*/
public final void filter_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast filter_spec_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(FILTER_SPEC,""));
expr();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
filter_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_227);
}
returnAST = filter_spec_AST;
}
/**
* Matches <code>INITIAL-FILTER</code> clause followed by an {@link #expr}.
* Used by {@link #filters_clause}.
*/
public final void initial_filter_num() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast initial_filter_num_AST = null;
try { // for error handling
Aast tmp1365_AST = null;
tmp1365_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1365_AST);
match(KW_INIT_FLT);
expr();
astFactory.addASTChild(currentAST, returnAST);
initial_filter_num_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_225);
}
returnAST = initial_filter_num_AST;
}
/**
* Matches <code>WINDOW-NAME</code> clause followed by an {@link #expr}.
* Used by {@link #system_help_stmt}.
*/
public final void window_name_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast window_name_clause_AST = null;
try { // for error handling
Aast tmp1366_AST = null;
tmp1366_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1366_AST);
match(KW_WIN_NAME);
expr();
astFactory.addASTChild(currentAST, returnAST);
window_name_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_228);
}
returnAST = window_name_clause_AST;
}
/**
* Matches all the various commands that can be passed to the {@link #system_help_stmt}. Uses
* {@link #expr}, {@link #position_clause_arg_x}, {@link #position_clause_arg_y},
* {@link #position_clause_arg_width} and {@link #position_clause_arg_height}.
*/
public final void help_command_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast help_command_clause_AST = null;
try { // for error handling
switch ( LA(1)) {
case KW_CONTENTS:
{
Aast tmp1367_AST = null;
tmp1367_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1367_AST);
match(KW_CONTENTS);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
case KW_FINDER:
{
Aast tmp1368_AST = null;
tmp1368_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1368_AST);
match(KW_FINDER);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
case KW_FORCE_F:
{
Aast tmp1369_AST = null;
tmp1369_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1369_AST);
match(KW_FORCE_F);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
case KW_HELP:
{
Aast tmp1370_AST = null;
tmp1370_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1370_AST);
match(KW_HELP);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
case KW_QUIT:
{
Aast tmp1371_AST = null;
tmp1371_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1371_AST);
match(KW_QUIT);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
case KW_ALT_KEY:
case KW_COMMAND:
case KW_CTX:
case KW_CTX_POP:
case KW_HELP_TOP:
case KW_KEY:
case KW_PART_KEY:
case KW_SET_CONT:
{
{
switch ( LA(1)) {
case KW_CTX:
{
Aast tmp1372_AST = null;
tmp1372_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1372_AST);
match(KW_CTX);
break;
}
case KW_SET_CONT:
{
Aast tmp1373_AST = null;
tmp1373_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1373_AST);
match(KW_SET_CONT);
break;
}
case KW_CTX_POP:
{
Aast tmp1374_AST = null;
tmp1374_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1374_AST);
match(KW_CTX_POP);
break;
}
case KW_KEY:
{
Aast tmp1375_AST = null;
tmp1375_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1375_AST);
match(KW_KEY);
break;
}
case KW_PART_KEY:
{
Aast tmp1376_AST = null;
tmp1376_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1376_AST);
match(KW_PART_KEY);
break;
}
case KW_COMMAND:
{
Aast tmp1377_AST = null;
tmp1377_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1377_AST);
match(KW_COMMAND);
break;
}
case KW_HELP_TOP:
{
Aast tmp1378_AST = null;
tmp1378_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1378_AST);
match(KW_HELP_TOP);
break;
}
case KW_ALT_KEY:
{
Aast tmp1379_AST = null;
tmp1379_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1379_AST);
match(KW_ALT_KEY);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
case KW_MULT_KEY:
{
Aast tmp1380_AST = null;
tmp1380_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1380_AST);
match(KW_MULT_KEY);
expr();
astFactory.addASTChild(currentAST, returnAST);
Aast tmp1381_AST = null;
tmp1381_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1381_AST);
match(KW_TEXT);
expr();
astFactory.addASTChild(currentAST, returnAST);
help_command_clause_AST = (Aast)currentAST.root;
break;
}
default:
if ((LA(1)==KW_POS) && (LA(2)==KW_MAXIMIZE)) {
Aast tmp1382_AST = null;
tmp1382_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1382_AST);
match(KW_POS);
Aast tmp1383_AST = null;
tmp1383_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1383_AST);
match(KW_MAXIMIZE);
help_command_clause_AST = (Aast)currentAST.root;
}
else if ((LA(1)==KW_POS) && (LA(2)==KW_X)) {
Aast tmp1384_AST = null;
tmp1384_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1384_AST);
match(KW_POS);
position_clause_arg_x();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_y();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_width();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_height();
astFactory.addASTChild(currentAST, returnAST);
help_command_clause_AST = (Aast)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = help_command_clause_AST;
}
/**
* Matches {@code X} and a following {@link #expr}. Used by {@link #help_command_clause}.
*/
public final void position_clause_arg_x() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast position_clause_arg_x_AST = null;
try { // for error handling
Aast tmp1385_AST = null;
tmp1385_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1385_AST);
match(KW_X);
expr();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_x_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_229);
}
returnAST = position_clause_arg_x_AST;
}
/**
* Matches {@code Y} and a following {@link #expr}. Used by {@link #help_command_clause}.
*/
public final void position_clause_arg_y() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast position_clause_arg_y_AST = null;
try { // for error handling
Aast tmp1386_AST = null;
tmp1386_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1386_AST);
match(KW_Y);
expr();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_y_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_230);
}
returnAST = position_clause_arg_y_AST;
}
/**
* Matches {@code WIDTH} and a following {@link #expr}. Used by {@link #help_command_clause}.
*/
public final void position_clause_arg_width() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast position_clause_arg_width_AST = null;
try { // for error handling
Aast tmp1387_AST = null;
tmp1387_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1387_AST);
match(KW_WIDTH);
expr();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_width_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_231);
}
returnAST = position_clause_arg_width_AST;
}
/**
* Matches {@code HEIGHT} and a following {@link #expr}. Used by {@link #help_command_clause}.
*/
public final void position_clause_arg_height() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast position_clause_arg_height_AST = null;
try { // for error handling
Aast tmp1388_AST = null;
tmp1388_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1388_AST);
match(KW_HEIGHT_C);
expr();
astFactory.addASTChild(currentAST, returnAST);
position_clause_arg_height_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_36);
}
returnAST = position_clause_arg_height_AST;
}
/**
* Matches the <code>BEFORE-TABLE</code> clause with the following {@link #symbol}. Used
* from {@link #def_temp_table_stmt}.
*
* @return The before-table name to define.
*/
public final String before_table_clause() throws RecognitionException, TokenStreamException {
String tname = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast before_table_clause_AST = null;
Aast t_AST = null;
try { // for error handling
Aast tmp1389_AST = null;
tmp1389_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1389_AST);
match(KW_B4_TABLE);
symbol();
t_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
tname = t_AST.getText();
before_table_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = before_table_clause_AST;
return tname;
}
/**
* Matches a field definition when creating a temp-table using the
* <code>DEFINE TEMP-TABLE or DEFINE WORK-TABLE</code> statements. Called
* by {@link #def_temp_table_stmt} rules.
* <p>
* Calls {@link #symbol}, {@link #as_field_clause}, {@link #like_clause}
* and {@link #temp_table_field_options}. As an undocumented feature, the
* <code>temp_table_field_options</code> can be matched before the
* <code>AS</code> or <code>LIKE</code> clause. This was found in working
* 4GL code and is supported.
* <p>
* This rule parses the field name, type and any options. The table object
* that the field is associated with is passed in as a parameter. This is
* used with the name and type to add the field to the schema namespace.
* <p>
* <b>An artificial root node is created to contain all tokens under a single
* root with type <code>DEFINE_FIELD</code>. This rule uses a trick to create
* an artificial node as a root while still allowing ANTLR to do normal tree
* building (no suppression of the AST build).</b> This is only useful in
* cases where there is no valid token which can be used as a tree root AND
* where a loop is being used such that the contents of the loop cannot be
* referenced in a manually built #([,],,,) ANTLR construct. ANTLR doesn't
* support (as of 2.7.4) the ability to label a loop such that the entire
* contents can be referenced. If one labels the individual elements inside
* the loop, only the last one is available when the loop concludes.
* However, by leaving the normal tree creation unchanged but manually
* creating an artificial node and manually setting this node as the root
* of the returned tree BEFORE the children are added, this problem can be
* solved.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*
* @param table
* The table object to associate this field with in the schema
* namespace.
*/
public final void add_temp_table_field(
Object table
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast add_temp_table_field_AST = null;
Token fi = null;
Aast fi_AST = null;
Aast f_AST = null;
Aast a_AST = null;
Aast l_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(DEFINE_FIELD,"define field"));
String fname = null;
int ftype = -1;
{
if ((LA(1)==KW_FIELD)) {
fi = LT(1);
fi_AST = (Aast)astFactory.create(fi);
match(KW_FIELD);
hide(fi);
}
else if ((_tokenSet_15.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
symbol();
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
fname = f_AST.getText();
{
if ((_tokenSet_232.member(LA(1))) && (_tokenSet_52.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
temp_table_field_options(fname, ftype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_AS||LA(1)==KW_LIKE||LA(1)==KW_LIKE_SEQ) && (_tokenSet_81.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_AS:
{
as_field_clause(fname, table);
a_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ftype = a_AST.getFirstChild().getType();
break;
}
case KW_LIKE:
case KW_LIKE_SEQ:
{
like_clause(fname, table, false);
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
ftype = l_AST.getFirstChild().getType();
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
temp_table_field_options(fname, ftype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
add_temp_table_field_AST = (Aast)currentAST.root;
// this should be able to find the right field because the temp-tab
// should be in the closest scope, thus the options will be forced
// into the field just defined
sym.setFieldOptions(fname, add_temp_table_field_AST);
add_temp_table_field_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = add_temp_table_field_AST;
}
/**
* Matches an index definition of a <code>DEFINE TEMP-TABLE</code> language
* statement. Calls {@link #symbol}, {@link #is_clause} and
* {@link #index_field_clause}.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Used by {@link #def_temp_table_stmt}.
*
* @param table
* The temp-table object that is being modified.
*/
public final void index_clause(
Object table
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast index_clause_AST = null;
Token i = null;
Aast i_AST = null;
Aast s_AST = null;
String idxName = null;
Token tok = LT(2);
try { // for error handling
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.makeASTRoot(currentAST, i_AST);
match(KW_INDEX);
any_non_reserved_symbol();
s_AST = (Aast)returnAST;
// not sure why ANTLR treats this differently, but we were not able to use a label
// here, we had to cache the token above instead; not sure why but we actually do
// also need to have a label there
idxName = tok.getText();
hide(tok);
// this will store the "index" keyword text as the "original-text" annotation while
// placing the index name (from the symbol) as the new text for the #i node
saveAndReplaceTypeAndText(i_AST, INDEX, idxName);
{
_loop1443:
do {
if ((LA(1)==KW_AS||LA(1)==KW_IS)) {
is_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1443;
}
} while (true);
}
{
int _cnt1445=0;
_loop1445:
do {
if ((_tokenSet_15.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
index_field_clause(table);
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt1445>=1 ) { break _loop1445; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1445++;
} while (true);
}
// can't reference ## here for some reason!
sym.addIndex(table, idxName, i_AST);
index_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = index_clause_AST;
}
/**
* Matches the field options that can be specified when creating a temp-table
* using the <code>DEFINE TEMP-TABLE or DEFINE WORK-TABLE</code> statements.
* Called by {@link #add_temp_table_field}.
* <p>
* All options can be specified in any order.
* <p>
* Calls:
* <p>
* <ul>
* <li> {@link #extent}
* <li> {@link #initializer}
* <li> {@link #label}
* <li> {@link #ui_stuff}
* <li> {@link #format_string}
* <li> {@link #help_string}
* <li> {@link #column_label}
* <li> {@link #decimals_clause}
* <li> {@link #view_as_phrase}
* <li> {@link #case_sensitive}
* </ul>
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*
* @param symText
* The name of the symbol being added which is passed to the
* view-as phrase so that the widget namespace can be maintained
* properly.
* @param ftype
* A token type that describes type of the field being created. This is the type
* of the child of the <code>KW_AS</code> or <code>KW_LIKE</code> node.
*/
public final void temp_table_field_options(
String symText, int ftype
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast temp_table_field_options_AST = null;
try { // for error handling
int size = -1;
int initcount= -1;
boolean containsExtent = false;
{
_loop1436:
do {
if ((LA(1)==KW_TTCP) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1390_AST = null;
tmp1390_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1390_AST);
match(KW_TTCP);
}
else if ((LA(1)==KW_MAND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1391_AST = null;
tmp1391_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1391_AST);
match(KW_MAND);
}
else if ((LA(1)==KW_COL_CP) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
column_codepage();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_EXTENT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
size=extent();
astFactory.addASTChild(currentAST, returnAST);
containsExtent = true;
}
else if ((LA(1)==KW_INIT) && (_tokenSet_55.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
initcount=initializer(ftype);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_LABEL) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
label(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_47.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
ui_stuff();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_HELP) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
help_string();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_COL_LAB) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
column_label();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DECIMALS) && (LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
decimals_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CASE_SEN||LA(1)==KW_NOT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
case_sensitive();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SERIALZH) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1392_AST = null;
tmp1392_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1392_AST);
match(KW_SERIALZH);
}
else if ((LA(1)==KW_SERIALZN) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
serialize_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_XML_DTYP) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
xml_data_type();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_XML_NTYP) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
xml_node_type();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_XML_NNAM) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3)))) {
xml_node_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_VIEW_AS) && (_tokenSet_56.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
view_as_phrase(null);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1436;
}
} while (true);
}
// Handle the situation where there may have been an initializer but no explicit extent
// initcount != -1 and size == -1 would be indicative of this.
if (containsExtent)
{
size = (size == -1 && initcount != -1) ? initcount : size;
}
temp_table_field_options_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = temp_table_field_options_AST;
}
/**
* Matches the <code>AS</code> language keyword that defines the data type
* of a field to be added to the a temp-table. This rule encapsulates the
* logic of matching the correct variable data type and adding this field
* into the temp-table or work-table being defined.
* <p>
* This is called from {@link #add_temp_table_field}.
* <p>
* The inclusion of the {@link #reserved_or_symbol} rule in the second token
* position ensures that all possible symbols are considered a possible field
* type and will be matched by this rule. This means that the calling rules
* include a list of reserved and unreserved keywords or generic symbols as
* one of the options for its 2nd token, thus "pulling" the
* recursive descent processing down into this rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code>, random keyword match or anything
* other than one of the valid <b>special abbreviations</b> for a field type.
* What we really require is a token that is one of the following:
* <pre>
* Data Type Keyword Actual Minimum Abbrev Lexer Abbrev
* ----------------- --------------------- -------------
* KW_BLOB n/a n/a
* KW_CHAR c char
* KW_CLASS n/a n/a
* KW_CLOB n/a n/a
* KW_COM_HNDL n/a n/a
* KW_DATE da n/a
* KW_DATETIME n/a n/a
* KW_DATE_TZ n/a n/a
* KW_DEC de dec
* KW_HANDLE handle n/a
* KW_INT i int
* KW_INT64 n/a n/a
* KW_LOGICAL l n/a
* KW_LONGCHAR NOT SUPPORTED AS A FIELD!!!!!!!!!!!!!!!
* KW_MEMPTR NOT SUPPORTED AS A FIELD!!!!!!!!!!!!!!!
* KW_RAW ra n/a
* KW_RECID re n/a
* KW_ROWID row n/a
* KW_WID_HAND widg widget-h
* </pre>
* <p>
* The difference between a <code>SYMBOL</code> and a <code>KW_CHAR</code>
* can only be determined by context (the fact that the lookahead code has
* identified a match with a <code>SYMBOL</code> token which is a construct
* that can occur in an this rule). Thus <b>if</b> a match is found using
* lookahead (in the rule that calls this one), then it <b>must</b> be
* correct and necessary to convert the <code>SYMBOL</code> or other keyword
* token type into the correct keyword representing the field type, using a
* special abbreviation test. This is done in an init action that is
* processed at the beginning of this rule. In this way, the rest of the rule
* only sees the 2nd token as a field token type and never tries to
* call the <code>reserved_or_symbol</code> rule since calling that rule
* would actually try to match (and consume from the token stream) a
* <code>SYMBOL</code> or other keyword token type. <b>Specifying a rule
* reference to obtain its value from a lookahead perspective but then
* changing the token's type such that the rule reference never gets called,
* is the critical trick that enables context sensitive symbol names!</b>
* <p>
* This use of a pull rule is only necessary because Progress provides
* additional special abbreviation support in this construct. This is a set
* of reduced abbreviations (see table above) beyond the normal (documented
* or undocumented) abbreviations of a field type keyword as is possible
* elsewhere in Progress source code. The <code>reserved_or_symbol</code>
* is needed because some possible reserved keyword matches could occur
* that would match one of these special abbreviations and thus the
* <code>symbol</code> rule would not be sufficient to pull all possible
* valid keyword matches into this rule.
* <p>
* The init action reads the text of the 2nd token and switches the token
* type to that of the matching field type keyword, if any special
* abbreviation is found. All such processing is bypassed if the lexer
* has already matched a valid field type keyword.
* <p>
* The logic of the special abbreviation processing is centralized in the
* specialDataTypeKeywordAbbreviations() method.
*
* @param symName
* The name of the field to add.
* @param table
* The table in which the field should be added.
*/
public final void as_field_clause(
String symName, Object table
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast as_field_clause_AST = null;
Token cl = null;
Aast cl_AST = null;
try { // for error handling
int ftype = -1;
specialDataTypeKeywordAbbreviations(2);
{
Aast tmp1393_AST = null;
tmp1393_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1393_AST);
match(KW_AS);
{
if ((LA(1)==KW_BLOB) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1394_AST = null;
tmp1394_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1394_AST);
match(KW_BLOB);
ftype = FIELD_BLOB;
}
else if ((LA(1)==KW_CHAR) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1395_AST = null;
tmp1395_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1395_AST);
match(KW_CHAR);
ftype = FIELD_CHAR;
}
else if ((LA(1)==KW_CLOB) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1396_AST = null;
tmp1396_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1396_AST);
match(KW_CLOB);
ftype = FIELD_CLOB;
}
else if ((LA(1)==KW_COM_HNDL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1397_AST = null;
tmp1397_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1397_AST);
match(KW_COM_HNDL);
ftype = FIELD_COM_HANDLE;
}
else if ((LA(1)==KW_DATE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1398_AST = null;
tmp1398_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1398_AST);
match(KW_DATE);
ftype = FIELD_DATE;
}
else if ((LA(1)==KW_DATETIME) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1399_AST = null;
tmp1399_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1399_AST);
match(KW_DATETIME);
ftype = FIELD_DATETIME;
}
else if ((LA(1)==KW_DATE_TZ) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1400_AST = null;
tmp1400_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1400_AST);
match(KW_DATE_TZ);
ftype = FIELD_DATETIME_TZ;
}
else if ((LA(1)==KW_DEC) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1401_AST = null;
tmp1401_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1401_AST);
match(KW_DEC);
ftype = FIELD_DEC;
}
else if ((LA(1)==KW_HANDLE) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1402_AST = null;
tmp1402_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1402_AST);
match(KW_HANDLE);
ftype = FIELD_HANDLE;
}
else if ((LA(1)==KW_INT) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1403_AST = null;
tmp1403_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1403_AST);
match(KW_INT);
ftype = FIELD_INT;
}
else if ((LA(1)==KW_INT64) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1404_AST = null;
tmp1404_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1404_AST);
match(KW_INT64);
ftype = FIELD_INT64;
}
else if ((LA(1)==KW_LOGICAL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1405_AST = null;
tmp1405_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1405_AST);
match(KW_LOGICAL);
ftype = FIELD_LOGICAL;
}
else if ((LA(1)==KW_RAW) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1406_AST = null;
tmp1406_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1406_AST);
match(KW_RAW);
ftype = FIELD_RAW;
}
else if ((LA(1)==KW_RECID) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1407_AST = null;
tmp1407_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1407_AST);
match(KW_RECID);
ftype = FIELD_RECID;
}
else if ((LA(1)==KW_ROWID) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1408_AST = null;
tmp1408_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1408_AST);
match(KW_ROWID);
ftype = FIELD_ROWID;
}
else if ((LA(1)==KW_WID_HAND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1409_AST = null;
tmp1409_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1409_AST);
match(KW_WID_HAND);
ftype = FIELD_HANDLE;
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
if ((LA(1)==KW_CLASS) && (_tokenSet_0.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
cl = LT(1);
cl_AST = (Aast)astFactory.create(cl);
match(KW_CLASS);
hide(cl);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
ftype = FIELD_CLASS;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
as_field_clause_AST = (Aast)currentAST.root;
sym.addField(table, symName, ftype, as_field_clause_AST);
sym.promoteTable(table, true, false, false);
as_field_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = as_field_clause_AST;
}
/**
* Matches the <code>COLUMN-CODEPAGE</code> option with a following
* {@link #expr}. Used by {@link #temp_table_field_options}.
*/
public final void column_codepage() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast column_codepage_AST = null;
try { // for error handling
Aast tmp1410_AST = null;
tmp1410_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1410_AST);
match(KW_COL_CP);
expr();
astFactory.addASTChild(currentAST, returnAST);
column_codepage_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = column_codepage_AST;
}
/**
* Matches <code>XML-DATA-TYPE</code> with a following <code>STRING</code>. Used by
* {@link #temp_table_field_options}.
*/
public final void xml_data_type() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast xml_data_type_AST = null;
try { // for error handling
Aast tmp1411_AST = null;
tmp1411_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1411_AST);
match(KW_XML_DTYP);
Aast tmp1412_AST = null;
tmp1412_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1412_AST);
match(STRING);
xml_data_type_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = xml_data_type_AST;
}
/**
* Matches the <code>IS</code> keyword of a <code>DEFINE TEMP-TABLE</code>
* language statement and handles the optional index qualifiers. Note that
* <b>Progress also allows the <code>AS</code> keyword to be substituted for
* <code>IS</code> although this is undocumented!</b> This rule supports
* both forms but the token type is always set to <code>KW_IS</code> to
* simplify tree processing.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Used by {@link #index_clause}.
*/
public final void is_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast is_clause_AST = null;
Token i = null;
Aast i_AST = null;
Token k = null;
Aast k_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_IS:
{
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.makeASTRoot(currentAST, i_AST);
match(KW_IS);
i_AST.setType(PROPERTIES);
break;
}
case KW_AS:
{
k = LT(1);
k_AST = (Aast)astFactory.create(k);
astFactory.makeASTRoot(currentAST, k_AST);
match(KW_AS);
k_AST.setType(PROPERTIES);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop1449:
do {
if ((LA(1)==KW_UNIQUE)) {
Aast tmp1413_AST = null;
tmp1413_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1413_AST);
match(KW_UNIQUE);
}
else if ((LA(1)==KW_PRIMARY) && (_tokenSet_233.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1414_AST = null;
tmp1414_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1414_AST);
match(KW_PRIMARY);
}
else if ((LA(1)==KW_WORD_IDX) && (_tokenSet_233.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1415_AST = null;
tmp1415_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1415_AST);
match(KW_WORD_IDX);
}
else {
break _loop1449;
}
} while (true);
}
is_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_54);
}
returnAST = is_clause_AST;
}
/**
* Matches the index field clause of a <code>DEFINE TEMP-TABLE</code> language statement. Calls
* {@link #symbol} and optionally {@link #sql_direction_spec} and roots everything under an
* artificial token <code>INDEX_FIELD</code>.
* <p>
* Note: There is an undocumented keyword, <code>case-sensitive</code>, that can qualify the
* index name.
* <p>
* We must NOT call {@link #lvalue} here, because the 4GL has very tight restrictions on what can
* match and using lvalue does a full schema-namespace lookup that can have ambiguity which the
* 4GL would not detect. The symbol is rewritten and annotated to be a field, so that the result
* is the same as if we has used <code>lvalue</code>. The 4GL restrictions:
* <p>
* <ul>
* <li> must be a field in the current temp-table/work-table definition
* <li> cannot be a qualified name
* <li> cannot be abbreviated
* <li> cannot reference an unsubscripted extent field
* <li> cannot reference a subscripted extent field
* </ul>
* <p>
* Used by {@link #index_clause}.
*
* @param table
* The temp-table object that is being modified.
*/
public final void index_field_clause(
Object table
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast index_field_clause_AST = null;
Aast s_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(INDEX_FIELD,"index field"));
symbol();
s_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
sym.annotateField(s_AST, table, false, false);
{
if ((LA(1)==KW_ASC||LA(1)==KW_DESCEND) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
sql_direction_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_CASE_SEN) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1416_AST = null;
tmp1416_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1416_AST);
match(KW_CASE_SEN);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
index_field_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = index_field_clause_AST;
}
/**
* Matches a Progress 4GL database reference that refers to a valid database
* or an alias to a valid database.
* <p>
* The matching portion of this rule is defined as a single token that
* matches the union of the <code>DATABASE</code> token type and the set of
* all possible alternatives for symbol names (a reference to the
* {@link #symbol} rule).
* <p>
* Note that if this rule is used as an alternative to a rule that includes a
* leftmost token defined by the <code>symbol</code> rule, there will be an
* ambiguity that is only resolved by lookahead <b>and</b> the proper
* ordering of the rules.
* <p>
* It is required that where this rule is referenced as one alternative that
* conflicts with the definitions of other alternatives, <b>the order of the
* alternatives must be more specific (in terms of matching criteria) to less
* specific</b>.
* <p>
* The inclusion of the <code>symbol</code> rule ensures that all valid
* symbols are considered a database and will be matched by this rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> since this could be anything. What we
* really require is a token that is type <code>DATABASE</code>.
* <p>
* The difference between a <code>SYMBOL</code> and a <code>DATABASE</code>
* can only be determined by context (the fact that the lookahead code has
* identified a match with a <code>SYMBOL</code> token which is a construct
* that can occur in a <code>database</code> call. Thus <b>if</b> a match is
* found using lookahead (in the rule that calls this one), then it
* <b>must</b> be correct and necessary to convert the <code>SYMBOL</code>
* token type into the correct type. This is done in an init action that is
* processed at the beginning of this rule. In this way, the rest of the rule
* only sees the first token as a valid <code>DATABASE</code> and never tries
* to call the <code>symbol</code> rule since calling that rule would actually
* try to match (and consume from the token stream) a <code>SYMBOL</code>
* token type. <b>Specifying a rule reference to obtain its value from a
* lookahead perspective but then changing the token's type such that the
* rule reference never gets called, is the critical trick that enables
* context sensitive symbol names!</b>
* <p>
* This rule can only be used in cases where it is non-optional OR there is
* no ambiguity (between the set of unreserved keywords referenced herein and
* any following keywords that would be improperly matched by this rule).
* In this case a semantic predicate could be used to isolate the conflicting
* token types and bypass this rule reference in those cases.
*/
public final void database() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast database_AST = null;
try { // for error handling
if (LA(1) != DATABASE)
{
int newtype = sym.lookupDatabase(LT(1).getText());
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if ( newtype != -1 )
{
LT(1).setType( newtype );
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==DATABASE)) {
Aast tmp1417_AST = null;
tmp1417_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1417_AST);
match(DATABASE);
}
else if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
database_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_6);
}
returnAST = database_AST;
}
/**
* Matches the <code>ROW or FIELD</code> keyword and the required following
* {@link #choose_field_spec}.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* Used by {@link #choose_stmt}.
*/
public final void choose_row_or_field_list() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast choose_row_or_field_list_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_ROW:
{
Aast tmp1418_AST = null;
tmp1418_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1418_AST);
match(KW_ROW);
choose_field_spec();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_FIELD:
{
Aast tmp1419_AST = null;
tmp1419_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1419_AST);
match(KW_FIELD);
{
int _cnt1502=0;
_loop1502:
do {
if ((_tokenSet_64.member(LA(1)))) {
choose_field_spec();
astFactory.addASTChild(currentAST, returnAST);
}
else {
if ( _cnt1502>=1 ) { break _loop1502; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1502++;
} while (true);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
choose_row_or_field_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_234);
}
returnAST = choose_row_or_field_list_AST;
}
/**
* Matches the <code>KEYS</code> keyword and the required following
* {@link #lvalue} of <code>CHARACTER</code> data type.
* <p>
* Used by {@link #choose_stmt}.
*/
public final void choose_keys_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast choose_keys_clause_AST = null;
Aast c_AST = null;
try { // for error handling
Aast tmp1420_AST = null;
tmp1420_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1420_AST);
match(KW_KEYS);
lvalue();
c_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (!( c_AST.getType() == VAR_CHAR || c_AST.getType() == FIELD_CHAR ))
throw new SemanticException(" c_AST.getType() == VAR_CHAR || c_AST.getType() == FIELD_CHAR ");
choose_keys_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_234);
}
returnAST = choose_keys_clause_AST;
}
/**
* Matches an {@link #lvalue} and an optional following
* {@link #choose_help_clause}.
* <p>
* Used by {@link #choose_row_or_field_list}.
*/
public final void choose_field_spec() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast choose_field_spec_AST = null;
try { // for error handling
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_HELP)) {
choose_help_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_235.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
choose_field_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_235);
}
returnAST = choose_field_spec_AST;
}
/**
* Matches the <code>HELP</code> keyword and the required following
* <code>STRING</code>.
* <p>
* Used by {@link #choose_field_spec}.
*/
public final void choose_help_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast choose_help_clause_AST = null;
try { // for error handling
Aast tmp1421_AST = null;
tmp1421_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1421_AST);
match(KW_HELP);
Aast tmp1422_AST = null;
tmp1422_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1422_AST);
match(STRING);
choose_help_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_235);
}
returnAST = choose_help_clause_AST;
}
/**
* Implements proper tree building for the most common field specification
* in the {@link #put_stmt}. Uses {@link #expr}, {@link #format_string} and
* {@link #to_or_at_clause}. Roots everything at a node of type
* <code>PUT_FIELD</code>.
*/
public final void put_field() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast put_field_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(PUT_FIELD,"output field"));
{
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1515:
do {
if ((LA(1)==KW_FORMAT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
format_string(true);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_AT||LA(1)==KW_TO) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
to_or_at_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1515;
}
} while (true);
}
}
put_field_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_21);
}
returnAST = put_field_AST;
}
/**
* Matches the <code>AT or TO</code> keywords and a required following
* expression. This is a variant of some constructs in the
* {@link #format_phrase} however this rule is not compatible with those
* rules. This calls {@link #expr} and is used by {@link #put_stmt}.
*/
public final void to_or_at_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast to_or_at_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_AT:
{
Aast tmp1423_AST = null;
tmp1423_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1423_AST);
match(KW_AT);
break;
}
case KW_TO:
{
Aast tmp1424_AST = null;
tmp1424_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1424_AST);
match(KW_TO);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
to_or_at_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_21);
}
returnAST = to_or_at_clause_AST;
}
/**
* Matches a <code>FROM</code> keyword and the following {@link #handle}.
* Used in the {@link #publish_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void from_handle_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast from_handle_clause_AST = null;
try { // for error handling
Aast tmp1425_AST = null;
tmp1425_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1425_AST);
match(KW_FROM);
expr();
astFactory.addASTChild(currentAST, returnAST);
from_handle_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_236);
}
returnAST = from_handle_clause_AST;
}
/**
* Matches a parenthesized list of comma-separated parameters used in a call-site and uses a
* rule reference to {@link #parameter} to properly build the AST. The parameters are optional
* as some customer code has been found that has an empty set of parenthesis.
* <p>
* Called from {@link #run_stmt}, {@link #function}, {@link #super_function},
* {@link #super_stmt}, {@link #run_super_stmt}, {@link #new_phrase},
* {@link #run_stored_proc_stmt} {@link #this_object_stmt} and {@link #publish_stmt}.
*
* @param allowAs
* {@code true} if the caller is should allow matching on an {@code as_clause}. This is an
* undocumented "feature" of the 4GL.
*/
public final void param_passing_list(
boolean allowAs
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast param_passing_list_AST = null;
Aast p_AST = null;
Aast p2_AST = null;
try { // for error handling
Aast tmp1426_AST = null;
tmp1426_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1426_AST);
match(LPARENS);
{
if ((_tokenSet_24.member(LA(1)))) {
parameter();
p_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_AS))&&( allowAs || p_AST.downPath(EXPRESSION, OBJECT_INVOCATION) )) {
as_clause(null, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==COMMA||LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1601:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
parameter();
p2_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_AS))&&( allowAs || p2_AST.downPath(EXPRESSION, OBJECT_INVOCATION) )) {
as_clause(null, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==COMMA||LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop1601;
}
} while (true);
}
}
else if ((LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
param_passing_list_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = param_passing_list_AST;
}
/**
* Matches a <code>PROCEDURE</code> keyword and the following {@link #handle}.
* Used in the {@link #subscribe_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void proc_handle_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast proc_handle_clause_AST = null;
try { // for error handling
Aast tmp1427_AST = null;
tmp1427_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1427_AST);
match(KW_PROC);
handle();
astFactory.addASTChild(currentAST, returnAST);
proc_handle_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_24);
}
returnAST = proc_handle_clause_AST;
}
/**
* Matches the <code>IN</code> keyword and the required following expression
* that resolves to the procedure handle construct in which the internal
* procedure is to be run.
* <p>
* Used by {@link #run_stmt}, {@link #dynamic_function_func}, {@link #event_proc_clause},
* {@link #subscribe_stmt} and {@link #unsubscribe_stmt}, the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void in_procedure_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast in_procedure_clause_AST = null;
try { // for error handling
Aast tmp1428_AST = null;
tmp1428_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1428_AST);
match(KW_IN);
expr();
astFactory.addASTChild(currentAST, returnAST);
in_procedure_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_237);
}
returnAST = in_procedure_clause_AST;
}
/**
* Matches a <code>RUN-PROCEDURE</code> keyword and the following
* character {@link #expr}. Used in the {@link #subscribe_stmt}.
* <p>
* This is only separated to simplify the AST build.
*/
public final void run_proc_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast run_proc_clause_AST = null;
try { // for error handling
Aast tmp1429_AST = null;
tmp1429_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1429_AST);
match(KW_RUN_PROC);
expr();
astFactory.addASTChild(currentAST, returnAST);
run_proc_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = run_proc_clause_AST;
}
/**
* Matches the list of {@link #expr} or {@link #space_or_skip} input for
* the {@link #msg_stmt}. The input can be made in any order and with any
* number of items. Everything will be rooted at a <code>CONTENT_ARRAY</code>
* node.
*/
public final void content_array() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast content_array_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(CONTENT_ARRAY,""));
{
_loop1548:
do {
if ((LA(1)==KW_SKIP||LA(1)==KW_SPACE) && (_tokenSet_21.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
space_or_skip();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_VIEW_AS && LA(1) != KW_SET && LA(1) != KW_UPDATE && LA(1) != KW_IN )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1548;
}
} while (true);
}
content_array_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_238);
}
returnAST = content_array_AST;
}
/**
* Matches the <code>VIEW-AS ALERT-BOX</code> construct and the optional
* following definitions. Calls {@link #buttons_clause} and
* {@link #simple_title_string} rules. It is unclear if the options need
* to be processed in any order. At the current time, they are only
* processed in a fixed order.
* <p>
* Used by {@link #msg_stmt}.
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void view_as_alert_box_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast view_as_alert_box_clause_AST = null;
try { // for error handling
Aast tmp1430_AST = null;
tmp1430_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1430_AST);
match(KW_VIEW_AS);
Aast tmp1431_AST = null;
tmp1431_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1431_AST);
match(KW_ALERT_BX);
{
switch ( LA(1)) {
case KW_MSG:
{
Aast tmp1432_AST = null;
tmp1432_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1432_AST);
match(KW_MSG);
break;
}
case KW_QUEST:
{
Aast tmp1433_AST = null;
tmp1433_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1433_AST);
match(KW_QUEST);
break;
}
case KW_INFO:
{
Aast tmp1434_AST = null;
tmp1434_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1434_AST);
match(KW_INFO);
break;
}
case KW_ERROR:
{
Aast tmp1435_AST = null;
tmp1435_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1435_AST);
match(KW_ERROR);
break;
}
case KW_WARN:
{
Aast tmp1436_AST = null;
tmp1436_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1436_AST);
match(KW_WARN);
break;
}
case DOT:
case KW_IN:
case KW_SET:
case KW_TITLE:
case KW_UPDATE:
case KW_VIEW_AS:
case KW_BUTTON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_BUTTON:
{
buttons_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_SET:
case KW_TITLE:
case KW_UPDATE:
case KW_VIEW_AS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_TITLE:
{
title_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_IN:
case KW_SET:
case KW_UPDATE:
case KW_VIEW_AS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
view_as_alert_box_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_238);
}
returnAST = view_as_alert_box_clause_AST;
}
/**
* Matches the <code>SET field or UPDATE field</code> construct and the
* required following as or like clause. Note that by using the
* {@link #as_clause} and {@link #like_clause} rules, the variable
* namespace is naturally updated which should be correct. Also uses
* {@link #lvalue} and {@link #format_string} rules. The options can
* be specified in any order.
* <p>
* Experience shows that a variable that is already defined can be
* redefined (or Progress ignores the second definition) using this
* phrase. For this reason, it is possible to encounter an
* <code>AS or LIKE</code> construct after an <code>lvalue</code>. However,
* this implementation is written to pass <code>null</code> as the symbol
* name which makes either called rule bypass the variable addition to
* the namespace. If it turns out that Progress actually redefines the
* variable, a change will be needed here. Normally, it is not possible
* to redefine a variable, so this behavior is unusual.
* <p>
* Used by {@link #msg_stmt}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void set_or_update_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_or_update_clause_AST = null;
Aast f_AST = null;
try { // for error handling
boolean newVar = false;
{
{
switch ( LA(1)) {
case KW_SET:
{
Aast tmp1437_AST = null;
tmp1437_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1437_AST);
match(KW_SET);
break;
}
case KW_UPDATE:
{
Aast tmp1438_AST = null;
tmp1438_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1438_AST);
match(KW_UPDATE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((_tokenSet_15.member(LA(1))) && (LA(2)==KW_AS||LA(2)==KW_LIKE||LA(2)==KW_LIKE_SEQ) && (_tokenSet_81.member(LA(3))))&&( sym.lookupVariable(LT(1).getText()) == -1 )) {
symbol();
f_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_AS:
{
as_clause(f_AST.getText(), false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LIKE:
case KW_LIKE_SEQ:
{
like_clause(f_AST.getText(), null, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
newVar = true;
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_AS:
{
as_clause(null, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LIKE:
case KW_LIKE_SEQ:
{
like_clause(null, null, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case DOT:
case KW_AUTO_RET:
case KW_FORMAT:
case KW_IN:
case KW_SET:
case KW_UPDATE:
case KW_VIEW_AS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
_loop1564:
do {
switch ( LA(1)) {
case KW_FORMAT:
{
format_string(false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_AUTO_RET:
{
Aast tmp1439_AST = null;
tmp1439_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1439_AST);
match(KW_AUTO_RET);
break;
}
default:
{
break _loop1564;
}
}
} while (true);
}
}
set_or_update_clause_AST = (Aast)currentAST.root;
if (newVar)
{
// pass the AST with all options to the symbol resolver to set
// those variable options accordingly (really only applies to the
// format_string and KW_AUTO_RET)
sym.setVariableOptions(f_AST.getText(), set_or_update_clause_AST);
// write any non-standard options into annotations (this will
// really only be the tempIdx since there are no real options
// in this form of variable definition)
sym.annotateVariableOptions(f_AST.getText(), set_or_update_clause_AST, true);
}
set_or_update_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_238);
}
returnAST = set_or_update_clause_AST;
}
/**
* Matches the <code>BUTTONS</code>keyword and the required following
* button set. Note that the <code>BUTTON</code> keyword is a valid
* abbreviation for <code>BUTTONS</code> but it is a separate keyword, used
* elsewhere in Progress. For this reason, this rule matches on both
* keywords and the token type is set to <code>BUTTONS</code> either way.
* <p>
* Used by {@link #view_as_alert_box_clause}.
* <p>
* The subtree is rooted by the keyword (which is the reason for using a
* separate rule for something so simple).
*/
public final void buttons_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast buttons_clause_AST = null;
try { // for error handling
Aast tmp1440_AST = null;
tmp1440_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1440_AST);
match(KW_BUTTON);
{
switch ( LA(1)) {
case KW_YES_NO:
{
Aast tmp1441_AST = null;
tmp1441_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1441_AST);
match(KW_YES_NO);
break;
}
case KW_YES_NO_C:
{
Aast tmp1442_AST = null;
tmp1442_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1442_AST);
match(KW_YES_NO_C);
break;
}
case KW_OK:
{
Aast tmp1443_AST = null;
tmp1443_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1443_AST);
match(KW_OK);
break;
}
case KW_OK_CAN:
{
Aast tmp1444_AST = null;
tmp1444_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1444_AST);
match(KW_OK_CAN);
break;
}
case KW_RETRY_C:
{
Aast tmp1445_AST = null;
tmp1445_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1445_AST);
match(KW_RETRY_C);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
buttons_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_239);
}
returnAST = buttons_clause_AST;
}
/**
* Matches one of the <code>PERSISTENT</code>, <code>SINGLE-RUN</code>, <code>SINGLETON</code> or
* <code>AS-THREAD</code> keywords and the optional following <code>SET</code> construct. The
* AS-THREAD is an optional FWD extension to run the given code on a new thread.
* <p>
* <b>Note that there is no procedure handle processing implemented at this time. The matching is
* done as a symbol only, no namespace is maintained.</b>
* <p>
* Used by {@link #run_stmt} and the subtree is rooted by the keyword (which is the reason for
* using a separate rule for something so simple).
*/
public final void persist_or_single_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast persist_or_single_clause_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_PERSIST:
{
Aast tmp1446_AST = null;
tmp1446_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1446_AST);
match(KW_PERSIST);
break;
}
case KW_SING_RUN:
{
Aast tmp1447_AST = null;
tmp1447_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1447_AST);
match(KW_SING_RUN);
break;
}
case KW_SINGLTON:
{
Aast tmp1448_AST = null;
tmp1448_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1448_AST);
match(KW_SINGLTON);
break;
}
case KW_AS_THRD:
{
Aast tmp1449_AST = null;
tmp1449_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1449_AST);
match(KW_AS_THRD);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==KW_SET) && (_tokenSet_64.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
set_handle();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
persist_or_single_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_136);
}
returnAST = persist_or_single_clause_AST;
}
/**
* Matches the <code>SET handle</code> clause and a following {@link #lvalue}
* which must be a handle type.
* <p>
* Used by {@link #persist_or_single_clause}, {@link #run_stmt} and
* {@link #asynch_clause}. The subtree is rooted by the keyword (which is
* the reason for using a separate rule for something so simple).
*/
public final void set_handle() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast set_handle_AST = null;
Aast l_AST = null;
try { // for error handling
Aast tmp1450_AST = null;
tmp1450_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1450_AST);
match(KW_SET);
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (!( isHandleType(l_AST) ))
throw new SemanticException(" isHandleType(l_AST) ");
set_handle_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_136);
}
returnAST = set_handle_AST;
}
/**
* Matches the <code>ON</code> keyword and the optional following
* <code>SERVER handle</code> construct.
* <p>
* <b>Note that there is no session or server handle processing implemented
* at this time. The matching is done as a symbol only, no namespace
* is maintained.</b>
* <p>
* Used by {@link #run_stmt} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
* <p>
* Ambiguity warnings are disabled because although ANTLR detects that the
* optional <code>SERVER</code> keyword could conflict with the following
* symbol, in fact Progress (and our implementation) both give preference
* to the keyword.
*/
public final void on_server_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast on_server_clause_AST = null;
try { // for error handling
Aast tmp1451_AST = null;
tmp1451_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1451_AST);
match(KW_ON);
{
if ((LA(1)==KW_SERVER) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1452_AST = null;
tmp1452_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1452_AST);
match(KW_SERVER);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_TRANS) && (_tokenSet_136.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
trans_distinct_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
on_server_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_136);
}
returnAST = on_server_clause_AST;
}
/**
* Matches the <code>ASYNCHRONOUS</code> clause and following options.
* Calls {@link #set_handle} and {@link #event_proc_clause}.
* <p>
* Used by {@link #run_stmt} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void asynch_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast asynch_clause_AST = null;
try { // for error handling
Aast tmp1453_AST = null;
tmp1453_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1453_AST);
match(KW_ASYNC);
{
if ((LA(1)==KW_SET) && (_tokenSet_64.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
set_handle();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==KW_EVT_PROC) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
event_proc_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
asynch_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_136);
}
returnAST = asynch_clause_AST;
}
/**
* Matches a list of expressions as valid preprocessor/compiler arguments
* in the <code>RUN</code> language statement and builds a single AST of
* the entire list, rooted at an artificial <code>ARGUMENTS</code> node.
* <p>
* As an undocumented 4GL feature, {@link #value} can be referenced instead of
* an expression.
* <p>
* <b>This rule uses a trick to create an artificial node as a root while
* still allowing ANTLR to do normal tree building (no suppression of the
* AST build).</b> This is only useful in cases where there is no valid
* token which can be used as a tree root AND where a loop is being used
* such that the contents of the loop cannot be referenced in a manually
* built #([,],,,) ANTLR construct. ANTLR doesn't support (as of 2.7.4) the
* ability to label a loop such that the entire contents can be referenced.
* If one labels the individual elements inside the loop, only the last one
* is available when the loop concludes. However, by leaving the normal
* tree creation unchanged but manually creating an artificial node and
* manually setting this node as the root of the returned tree BEFORE the
* children are added, this problem can be solved.
* <p>
* Though undocumented, customer source has shown that it is valid to
* insert a comma in between each preprocessor argument. These are
* optionally matched and discarded.
* <p>
* There is an undocumented feature of the 4GL where certain "junk" tokens can be matched
* instead of an expression. If the next token is DOT (without following whitespace), COLON,
* RPARENS, EQUALS, LBRACKET, RBRACKET, UNKNOWN_TOKEN (for "}" or "|"), COMMA, LT, GT or
* NOT_EQ then attempt to merge until WS is hit with an exclusion KW_VALUE and KW_NO_ERROR.
* The resulting token will be set to BROKEN_PREPROC_ARG (and matched that way). The only
* exception is LPARENS which is valid for this case in the 4GL, but which cannot be
* disambiguated from the use of LPARENS in a real expression (which also works). This
* LPARENS case remains a TODO.
* <p>
* Called by {@link #run_stmt}. This rule only exists to create the proper
* AST, otherwise it would be much simpler to inline since the match is
* trivial.
*/
public final void preproc_arguments() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast preproc_arguments_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(ARGUMENTS,"arguments"));
{
_loop1575:
do {
if ((LA(1)==KW_VALUE) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
value();
astFactory.addASTChild(currentAST, returnAST);
fixupBrokenPreprocArg();
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
fixupBrokenPreprocArg();
}
else if ((LA(1)==BROKEN_PREPROC_ARG)) {
Aast tmp1454_AST = null;
tmp1454_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1454_AST);
match(BROKEN_PREPROC_ARG);
fixupBrokenPreprocArg();
}
else {
break _loop1575;
}
} while (true);
}
preproc_arguments_AST = (Aast)currentAST.root;
if (preproc_arguments_AST.getNumberOfChildren() == 0) preproc_arguments_AST = null;
currentAST.root = preproc_arguments_AST;
currentAST.child = preproc_arguments_AST!=null &&preproc_arguments_AST.getFirstChild()!=null ?
preproc_arguments_AST.getFirstChild() : preproc_arguments_AST;
currentAST.advanceChildToEnd();
preproc_arguments_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_200);
}
returnAST = preproc_arguments_AST;
}
/**
* Matches the <code>TRANSACTION DISTINCT</code> clause. Although official documentation states
* that both keywords are needed to define the clause, practice showed the DISTINCT keyword is
* optional.
* <p>
* Used by {@link #run_stmt} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
*/
public final void trans_distinct_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast trans_distinct_clause_AST = null;
Token t = null;
Aast t_AST = null;
Token di = null;
Aast di_AST = null;
try { // for error handling
t = LT(1);
t_AST = (Aast)astFactory.create(t);
astFactory.makeASTRoot(currentAST, t_AST);
match(KW_TRANS);
t_AST.setType(TRANSACTION_DISTINCT);
{
if ((LA(1)==KW_DISTINCT) && (_tokenSet_136.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
di = LT(1);
di_AST = (Aast)astFactory.create(di);
match(KW_DISTINCT);
hide(di);
}
else if ((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
trans_distinct_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_136);
}
returnAST = trans_distinct_clause_AST;
}
/**
* Matches the <code>EVENT-PROCEDURE</code> clause and its required
* expression and optional {@link #in_procedure_clause}.
* <p>
* Used by {@link #asynch_clause} and the subtree is rooted by the keyword
* (which is the reason for using a separate rule for something so simple).
* <p>
* Bogus ANTLR ambiguity warnings have been disabled.
*/
public final void event_proc_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast event_proc_clause_AST = null;
try { // for error handling
Aast tmp1455_AST = null;
tmp1455_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1455_AST);
match(KW_EVT_PROC);
expr();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_IN) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
in_procedure_clause();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_136.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
event_proc_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_136);
}
returnAST = event_proc_clause_AST;
}
/**
* Matches a single parameter being passed at a call-site. The preceding <code>INPUT</code>,
* <code>INPUT-OUTPUT</code> and <code>OUTPUT</code> keywords are optional. The core parameter is
* matched using the {@link #expr} rule.
* <p>
* The <code>INPUT</code> keyword can also be found as the leftmost token in a conditional
* expression (there is a function by the same name that takes a single non-parenthesized
* parameter). This conflicts with the optional keyword here. Warnings has been disabled for that
* subrule as a result.
* <p>
* To actually use the <code>INPUT</code> built-in function as a parameter, one must paranthesize
* the call OR add the following FRAME frame-name qualifier between the KW_INPUT and the widget
* name. This is how it works in Progress! Otherwise the presence of the KW_INPUT is treated as
* an ignored mode qualifier.
* <p>
* The subtree returned from this rule will be rooted at an artificial node of type
* <code>PARAMETER</code>.
* <p>
* Called from {@link #param_passing_list}.
*/
public final void parameter() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast parameter_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(PARAMETER,"parameter"));
boolean isInputFunc = (LA(1) == KW_INPUT &&
LA(2) == KW_FRAME &&
resolveLvalueCoreType(4, false) != -1);
{
if (((LA(1)==KW_INPUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( !isInputFunc )) {
Aast tmp1456_AST = null;
tmp1456_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1456_AST);
match(KW_INPUT);
}
else if ((LA(1)==KW_OUTPUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1457_AST = null;
tmp1457_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1457_AST);
match(KW_OUTPUT);
}
else if ((LA(1)==KW_IN_OUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1458_AST = null;
tmp1458_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1458_AST);
match(KW_IN_OUT);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1609:
do {
switch ( LA(1)) {
case KW_APPEND:
{
Aast tmp1459_AST = null;
tmp1459_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1459_AST);
match(KW_APPEND);
break;
}
case KW_BY_VALUE:
{
Aast tmp1460_AST = null;
tmp1460_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1460_AST);
match(KW_BY_VALUE);
break;
}
case KW_BY_REF:
{
Aast tmp1461_AST = null;
tmp1461_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1461_AST);
match(KW_BY_REF);
break;
}
case KW_BIND:
{
Aast tmp1462_AST = null;
tmp1462_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1462_AST);
match(KW_BIND);
break;
}
default:
{
break _loop1609;
}
}
} while (true);
}
parameter_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_240);
}
returnAST = parameter_AST;
}
/**
* Matches a single statement parameter definition for methods, constructors, destructors,
* property getters/setters and user-defined function definitions. This is not used at
* call-sites but only to define the interface for the given callable unit.
* <p>
* Optionally matches <code>INPUT, INPUT-OUTPUT and OUTPUT</code> keywords or a
* <code>BUFFER</code> definition as well as a range of possible table parameter types.
* The {@link #table_parm}, {@link #def_buf_stmt} and {@link #as_clause} rules are used.
* <p>
* This rule will define new variables in the variable dictionary. For normal variables it
* calls the {@link #as_clause} rule to add this variable name into the variable dictionary
* with the correct data type. Note that this rule passes the variable name as a
* <code>String</code> argument to the <code>as_clause</code> rule since this current rule has
* the knowledge of this name but doesn't have the knowledge of how to deal with the data types
* and variable dictionary.
* <p>
* Instead of an AS clause, this will also match the undocumented {@link #like_clause}.
* <p>
* For buffers and other table parameters, these are each handled by separate rules.
* <p>
* Note that it seems that the 2nd alternative (a symbol followed by the
* <code>AS</code> keyword) should be detected as ambiguous with the
* 3rd alternative (an expression). However ANTLR automatically inserts
* a test for the 2nd token being equivalent to <code>AS</code> which
* disambiguates these alternatives. This may be due to the use of a rule
* reference rather than an inline keyword implementation. <b>If this coding
* changes, a semantic predicate may have to be used to manually disambiguate.
* There will be no ANTLR warnings since these have been disabled, so you
* MUST exercise great care in modifying this rule.</b>
* <p>
* The <code>INPUT</code> keyword can also be found as the leftmost token
* in a conditional expression (there is a function by the same name that
* takes a single non-parenthesized parameter). This conflicts with the
* optional keyword here, but we will match first on this keyword and this
* is the correct behavior. Warnings has been disabled for that subrule as
* a result.
* <p>
* The subtree returned from this rule will be rooted at an artificial node
* of type <code>PARAMETER</code>.
* <p>
* Called from {@link #param_list_definition}.
*
* @param defineBuffer
* <code>true</code> if the caller supports inline buffer
* definitions (versus just passing a buffer parameter which
* doesn't create a new buffer).
* @param funcDef
* <code>true</code> if the caller is a FUNCTION definition.
* @param oo
* {@code true} if being called from OO features. In OO usage, reserved keywords can
* be used as parameter names.
*/
public final void parameter_spec(
boolean defineBuffer, boolean funcDef, boolean oo
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast parameter_spec_AST = null;
Token k1 = null;
Aast k1_AST = null;
Token k2 = null;
Aast k2_AST = null;
Token k3 = null;
Aast k3_AST = null;
Aast tp_AST = null;
Aast buf_AST = null;
Aast param_AST = null;
Aast res_AST = null;
Aast vt_AST = null;
try { // for error handling
String varname = null;
boolean abbrev = false;
int size = -1;
// this should really be changed to a different token type to differentiate it from
// the parameter passing syntax in the parameter rule
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(PARAMETER,"parameter"));
{
if ((LA(1)==KW_INPUT) && (_tokenSet_0.member(LA(2))) && (_tokenSet_241.member(LA(3)))) {
k1 = LT(1);
k1_AST = (Aast)astFactory.create(k1);
astFactory.addASTChild(currentAST, k1_AST);
match(KW_INPUT);
}
else if ((LA(1)==KW_OUTPUT) && (_tokenSet_0.member(LA(2))) && (_tokenSet_241.member(LA(3)))) {
k2 = LT(1);
k2_AST = (Aast)astFactory.create(k2);
astFactory.addASTChild(currentAST, k2_AST);
match(KW_OUTPUT);
}
else if ((LA(1)==KW_IN_OUT) && (_tokenSet_0.member(LA(2))) && (_tokenSet_241.member(LA(3)))) {
k3 = LT(1);
k3_AST = (Aast)astFactory.create(k3);
astFactory.addASTChild(currentAST, k3_AST);
match(KW_IN_OUT);
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_241.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((_tokenSet_57.member(LA(1))) && (_tokenSet_58.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
varname=table_parm();
tp_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_BUFFER) && (_tokenSet_242.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( defineBuffer )) {
def_buf_stmt(false, funcDef, false, null, null);
buf_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_27.member(LA(1))) && (LA(2)==KW_AS||LA(2)==KW_LIKE||LA(2)==KW_LIKE_SEQ) && (_tokenSet_81.member(LA(3)))) {
{
if (((_tokenSet_15.member(LA(1))) && (LA(2)==KW_AS||LA(2)==KW_LIKE||LA(2)==KW_LIKE_SEQ) && (_tokenSet_81.member(LA(3))))&&( !oo )) {
symbol();
param_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = param_AST.getText();
}
else if ((_tokenSet_27.member(LA(1))) && (LA(2)==KW_AS||LA(2)==KW_LIKE||LA(2)==KW_LIKE_SEQ) && (_tokenSet_81.member(LA(3)))) {
reserved_or_symbol();
res_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
varname = res_AST.getText();
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case KW_AS:
{
as_clause(varname, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_LIKE:
case KW_LIKE_SEQ:
{
like_clause(varname, null, false);
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_EXTENT:
{
size=extent();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COMMA:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_243.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
var_type(null, false);
vt_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
abbrev = true;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
parameter_spec_AST = (Aast)currentAST.root;
// this should only occur during function definitions and only for
// table handles or symbols followed by the AS keyword
if (varname != null)
{
// the only option to set is the parameter type
sym.setVariableOptions(varname, parameter_spec_AST);
// write any non-standard options into annotations (this probably
// only means the tempidx and extent since no other options are really
// possible)
sym.annotateVariableOptions(varname, parameter_spec_AST, true);
// check if the type was specified
if (k1_AST == null && k2_AST == null && k3_AST == null)
{
// default to KW_INPUT
parameter_spec_AST.putAnnotation("parmtype", Long.valueOf(KW_INPUT));
}
}
else
{
// in the parameter definition case where this is not a full
// variable definition (it is the abbreviated var def, a table,
// table-handle, buffer), create those annotations that are
// possible
Aast mode = (k1_AST == null) ? ((k2_AST == null) ? k3_AST : k2_AST) : k1_AST;
int ptype = (mode == null) ? KW_INPUT : mode.getType();
parameter_spec_AST.putAnnotation("parmtype", Long.valueOf(ptype));
Aast typ = (tp_AST == null) ? ((buf_AST == null) ? vt_AST : buf_AST) : tp_AST;
if (typ != null)
parameter_spec_AST.putAnnotation("type", Long.valueOf(typ.getType()));
}
// remember if this is an OO parameter def or a user-defined function parameter def
parameter_spec_AST.putAnnotation("isOO", oo);
parameter_spec_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_29);
}
returnAST = parameter_spec_AST;
}
/**
* Match the <code>integer-field = PROC-HANDLE</code> clause of the
* {@link #run_stored_proc_stmt} rule. This matches an {@link #lvalue}
* followed by an <code>EQUALS</code> and then another <code>lvalue</code>.
* The result is rooted at an <code>ASSIGN</code> node. This is separated
* to allow the tree to be built properly. Also called from the
* {@link #close_stored_proc_stmt}.
*/
public final void assign_proc_handle() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast assign_proc_handle_AST = null;
Token eq = null;
Aast eq_AST = null;
try { // for error handling
lvalue();
astFactory.addASTChild(currentAST, returnAST);
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(EQUALS);
eq_AST.setType(ASSIGN);
lvalue();
astFactory.addASTChild(currentAST, returnAST);
assign_proc_handle_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_244);
}
returnAST = assign_proc_handle_AST;
}
/**
* Implements the 2nd lowest precedence level of Progress 4GL expressions
* <code>KW_AND</code> (the logical AND) operator. This also matches the
* bitwise AND operator.
* <p>
* This is only called by the top level {@link #expr} rule. This method
* calls the {@link #bitwise_xor_expr} rule.
* <p>
* There is a bogus ambiguity warning generated by this rule (which occurs
* because of the addition of the special <code>IF THEN ELSE</code> function
* (see {@link #if_func}) in the {@link #primary_expr} rule. No real ambiguity
* seems to exist and no errors can be found, so warnings have been disabled.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
*/
public final void log_and_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast log_and_expr_AST = null;
Aast bx1_AST = null;
Token kwa = null;
Aast kwa_AST = null;
try { // for error handling
bitwise_xor_expr();
bx1_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop1646:
do {
if ((LA(1)==KW_AND) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
kwa = LT(1);
kwa_AST = (Aast)astFactory.create(kwa);
astFactory.makeASTRoot(currentAST, kwa_AST);
match(KW_AND);
if (isEnum(bx1_AST))
{
saveAndReplaceType(kwa_AST, BITWISE_AND);
}
checkExtraSpace(kwa_AST, false);
matchAssign = false;
bitwise_xor_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1646;
}
} while (true);
}
log_and_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = log_and_expr_AST;
}
/**
* Implements the 2nd lowest precedence level of Progress 4GL expressions
* <code>KW_XOR</code> (the bitwise XOR) operator.
* <p>
* This is only called by the top level {@link #expr} rule. This method
* calls the {@link #log_not_expr} rule.
* <p>
* There is a bogus ambiguity warning generated by this rule (which occurs
* because of the addition of the special <code>IF THEN ELSE</code> function
* (see {@link #if_func}) in the {@link #primary_expr} rule. No real ambiguity
* seems to exist and no errors can be found, so warnings have been disabled.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
*/
public final void bitwise_xor_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast bitwise_xor_expr_AST = null;
Token kwx = null;
Aast kwx_AST = null;
try { // for error handling
log_not_expr();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1649:
do {
if ((LA(1)==KW_XOR) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
kwx = LT(1);
kwx_AST = (Aast)astFactory.create(kwx);
astFactory.makeASTRoot(currentAST, kwx_AST);
match(KW_XOR);
// we do this for consistency only, it could have stayed as KW_XOR because it is
// unambiguous
saveAndReplaceType(kwx_AST, BITWISE_XOR);
checkExtraSpace(kwx_AST, false);
matchAssign = false;
log_not_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1649;
}
} while (true);
}
bitwise_xor_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = bitwise_xor_expr_AST;
}
/**
* Implements the 4th lowest precedence level of Progress 4GL expressions
* <code>KW_NOT</code> (the logical NOT) operator.
* <p>
* This is only called by the 2nd level {@link #log_and_expr} rule.
* This method calls the {@link #compare_expr} rule.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
*/
public final void log_not_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast log_not_expr_AST = null;
Token nt = null;
Aast nt_AST = null;
Aast ce_AST = null;
try { // for error handling
{
if ((LA(1)==KW_NOT) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
nt = LT(1);
nt_AST = (Aast)astFactory.create(nt);
astFactory.makeASTRoot(currentAST, nt_AST);
match(KW_NOT);
matchAssign = false;
}
else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
compare_expr();
ce_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
if (nt_AST != null && isEnum(ce_AST))
{
saveAndReplaceType(nt_AST, BITWISE_NOT);
}
log_not_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = log_not_expr_AST;
}
/**
* Implements the 5th lowest precedence level of Progress 4GL expressions
* - the comparison operators.
* <p>
* This is only called by the 3nd level {@link #log_not_expr} rule. This
* method subsequently calls the {@link #sum_expr} rule.
* <p>
* Provides the following operators:
* <pre>
* EQUALS or KW_EQ
* NOT_EQ or KW_NE
* GT or KW_GT
* LT or KW_LT
* GTE or KW_GTE
* LTE or KW_LTE
* KW_BEGINS
* KW_MATCHES
* KW_CONTAINS
* </pre>
* <p>
* When in an embedded SQL statement, the following additional operators
* are supported:
* <pre>
* KW_BETWEEN
* NOT_BETWEEN
* KW_LIKE
* NOT_LIKE
* KW_IN
* NOT_IN
* IS_NULL
* IS_NOT_NULL
* </pre>
* <p>
* If this is called from within a <code>WHERE</code> clause that is in
* an SQL {@link #select_stmt}, then all forms of sub-select are supported
* in this rule. Uses {@link #sub_select_stmt} and
* {@link #in_operator_sub_select_stmt} to provide this support.
* <p>
* Note that to eliminate ambiguity with the unreserved keywords listed
* above, if any of these keywords are found in the proper operator position
* we reset the token type to the associated non-keyword operator's type.
* <p>
* The other two alternative approaches each cause problems:
* <ul>
* <li> If the token type is not forced to the non-keyword type, then
* expression evaluation would be more complicated because more
* than one token type would generate the same action.
* <li> If the token type of the keyword was forced to the non-keyword
* corresponding operator by the lexer's keyword lookup mechanism,
* then the non-reserved keywords could never be used as user-defined
* symbols since the token type would always be set to the operators
* instead. This would not match how Progress works.
* </ul>
* <p>
* The approach taken allows for the lexer to <b>always</b> set the token
* type to the unreserved keyword (e.g. the text <code>EQ</code> is set to
* the <code>KW_EQ</code> token type. Then it is the parser's context that
* determines if that token matches into this rule or not. If so, the token
* type is rewritten to the correct matching operator. In this case it would
* be set to the token type <code>EQUALS</code> which is the same as if the
* lexer had encountered the '=' character. This generates a simple tree
* where the operators are well known. However, if the keyword is used as
* a symbol name (e.g. a variable), this will work unchanged as the lexer
* won't hard code the type as the operator. See {@link #lvalue} for more
* details.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
* <p>
* Note that ANTLR reports ambiguity between this rule and the {@link #assign}
* rule. The ambiguity is resolved by the ordering of the top level rule
* placing the <code>ASSIGN</code> language statement (which is unambiguous)
* with higher precedence than the <code>assignment</code> rule. As long as
* the <code>assign</code> rule is only used by the <code>assign_stmt</code>
* rule, there is no real ambiguity. For this reason, ambiguity warnings
* are suppressed for this rule.
*/
public final void compare_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast compare_expr_AST = null;
Token eq = null;
Aast eq_AST = null;
Token ne = null;
Aast ne_AST = null;
Token gt = null;
Aast gt_AST = null;
Token lt = null;
Aast lt_AST = null;
Token ge = null;
Aast ge_AST = null;
Token le = null;
Aast le_AST = null;
Token kwb = null;
Aast kwb_AST = null;
Token kwm = null;
Aast kwm_AST = null;
Token kwc = null;
Aast kwc_AST = null;
Token nb = null;
Aast nb_AST = null;
Token be = null;
Aast be_AST = null;
Token nl = null;
Aast nl_AST = null;
Token li = null;
Aast li_AST = null;
Token ni = null;
Aast ni_AST = null;
Token in = null;
Aast in_AST = null;
Token inn = null;
Aast inn_AST = null;
Token no = null;
Aast no_AST = null;
Token nu = null;
Aast nu_AST = null;
Token inu = null;
Aast inu_AST = null;
Token nu2 = null;
Aast nu2_AST = null;
try { // for error handling
boolean inBetween = false;
boolean inLike = false;
boolean inIn = false;
boolean isNull = false;
boolean avoid = false;
sum_expr();
astFactory.addASTChild(currentAST, returnAST);
// additional code to bypass the operator checking in the case
// where were ARE NOT in embedded SQL mode and there is a following
// keyword that might be confused with an embedded SQL operator
// (for example, in def_var_stmt where there is a like_clause that
// follows a format_string)
int ttype = LA(1);
avoid = !embeddedSql && (ttype == KW_LIKE ||
ttype == KW_NOT ||
ttype == KW_IN ||
ttype == KW_BETWEEN ||
ttype == KW_IS);
{
if (((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !avoid )) {
{
_loop1659:
do {
if ((_tokenSet_245.member(LA(1))) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
matchAssign = false;
{
switch ( LA(1)) {
case EQUALS:
{
Aast tmp1463_AST = null;
tmp1463_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1463_AST);
match(EQUALS);
break;
}
case KW_EQ:
{
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(KW_EQ);
checkExtraSpace(eq_AST, true); eq_AST.setType(EQUALS);
break;
}
case NOT_EQ:
{
Aast tmp1464_AST = null;
tmp1464_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1464_AST);
match(NOT_EQ);
break;
}
case KW_NE:
{
ne = LT(1);
ne_AST = (Aast)astFactory.create(ne);
astFactory.makeASTRoot(currentAST, ne_AST);
match(KW_NE);
checkExtraSpace(ne_AST, true); ne_AST.setType(NOT_EQ);
break;
}
case GT:
{
Aast tmp1465_AST = null;
tmp1465_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1465_AST);
match(GT);
break;
}
case KW_GT:
{
gt = LT(1);
gt_AST = (Aast)astFactory.create(gt);
astFactory.makeASTRoot(currentAST, gt_AST);
match(KW_GT);
checkExtraSpace(gt_AST, true); gt_AST.setType(GT);
break;
}
case LT:
{
Aast tmp1466_AST = null;
tmp1466_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1466_AST);
match(LT);
break;
}
case KW_LT:
{
lt = LT(1);
lt_AST = (Aast)astFactory.create(lt);
astFactory.makeASTRoot(currentAST, lt_AST);
match(KW_LT);
checkExtraSpace(lt_AST, true); lt_AST.setType(LT);
break;
}
case GTE:
{
Aast tmp1467_AST = null;
tmp1467_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1467_AST);
match(GTE);
break;
}
case KW_GTE:
{
ge = LT(1);
ge_AST = (Aast)astFactory.create(ge);
astFactory.makeASTRoot(currentAST, ge_AST);
match(KW_GTE);
checkExtraSpace(ge_AST, true); ge_AST.setType(GTE);
break;
}
case LTE:
{
Aast tmp1468_AST = null;
tmp1468_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1468_AST);
match(LTE);
break;
}
case KW_LTE:
{
le = LT(1);
le_AST = (Aast)astFactory.create(le);
astFactory.makeASTRoot(currentAST, le_AST);
match(KW_LTE);
checkExtraSpace(le_AST, true); le_AST.setType(LTE);
break;
}
case KW_BEGINS:
{
kwb = LT(1);
kwb_AST = (Aast)astFactory.create(kwb);
astFactory.makeASTRoot(currentAST, kwb_AST);
match(KW_BEGINS);
checkExtraSpace(kwb_AST, false);
break;
}
case KW_MATCHES:
{
kwm = LT(1);
kwm_AST = (Aast)astFactory.create(kwm);
astFactory.makeASTRoot(currentAST, kwm_AST);
match(KW_MATCHES);
checkExtraSpace(kwm_AST, false);
break;
}
case KW_CONTAINS:
{
kwc = LT(1);
kwc_AST = (Aast)astFactory.create(kwc);
astFactory.makeASTRoot(currentAST, kwc_AST);
match(KW_CONTAINS);
checkExtraSpace(kwc_AST, false);
break;
}
default:
if (((_tokenSet_246.member(LA(1))))&&( embeddedSql )) {
{
switch ( LA(1)) {
case KW_BETWEEN:
{
Aast tmp1469_AST = null;
tmp1469_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1469_AST);
match(KW_BETWEEN);
inBetween = true;
break;
}
case KW_LIKE:
{
Aast tmp1470_AST = null;
tmp1470_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1470_AST);
match(KW_LIKE);
inLike = true;
break;
}
case KW_IN:
{
Aast tmp1471_AST = null;
tmp1471_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1471_AST);
match(KW_IN);
inIn = true;
break;
}
default:
if ((LA(1)==KW_NOT) && (LA(2)==KW_BETWEEN)) {
nb = LT(1);
nb_AST = (Aast)astFactory.create(nb);
astFactory.makeASTRoot(currentAST, nb_AST);
match(KW_NOT);
be = LT(1);
be_AST = (Aast)astFactory.create(be);
match(KW_BETWEEN);
hide(be);
nb_AST.setType(NOT_BETWEEN);
inBetween = true;
}
else if ((LA(1)==KW_NOT) && (LA(2)==KW_LIKE)) {
nl = LT(1);
nl_AST = (Aast)astFactory.create(nl);
astFactory.makeASTRoot(currentAST, nl_AST);
match(KW_NOT);
li = LT(1);
li_AST = (Aast)astFactory.create(li);
match(KW_LIKE);
hide(li);
nb_AST.setType(NOT_LIKE);
inLike = true;
}
else if ((LA(1)==KW_NOT) && (LA(2)==KW_IN)) {
ni = LT(1);
ni_AST = (Aast)astFactory.create(ni);
astFactory.makeASTRoot(currentAST, ni_AST);
match(KW_NOT);
in = LT(1);
in_AST = (Aast)astFactory.create(in);
match(KW_IN);
hide(in);
ni_AST.setType(NOT_IN);
inIn = true;
}
else if ((LA(1)==KW_IS) && (LA(2)==KW_NOT)) {
inn = LT(1);
inn_AST = (Aast)astFactory.create(inn);
astFactory.makeASTRoot(currentAST, inn_AST);
match(KW_IS);
no = LT(1);
no_AST = (Aast)astFactory.create(no);
match(KW_NOT);
hide(no);
nu = LT(1);
nu_AST = (Aast)astFactory.create(nu);
match(KW_NULL);
hide(nu);
in_AST.setType(IS_NOT_NULL);
isNull = true;
}
else if ((LA(1)==KW_IS) && (LA(2)==KW_NULL)) {
inu = LT(1);
inu_AST = (Aast)astFactory.create(inu);
astFactory.makeASTRoot(currentAST, inu_AST);
match(KW_IS);
nu2 = LT(1);
nu2_AST = (Aast)astFactory.create(nu2);
match(KW_NULL);
hide(nu2);
inu_AST.setType(IS_NULL);
isNull = true;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if (((LA(1)==LPARENS) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( inIn )) {
in_operator_parms();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_247.member(LA(1))) && (LA(2)==KW_EXISTS||LA(2)==KW_SELECT||LA(2)==LPARENS) && (_tokenSet_152.member(LA(3))))&&( embeddedSql && selectNestLevel > 1 )) {
sub_select_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_24.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( !isNull )) {
sum_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if (((LA(1)==KW_AND) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( inBetween )) {
and_expr();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_ESCAPE) && (LA(2)==STRING) && (_tokenSet_3.member(LA(3))))&&( inLike )) {
escape_char();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_IN||LA(1)==KW_NOT) && (LA(2)==KW_IN||LA(2)==LPARENS) && (_tokenSet_24.member(LA(3))))&&( embeddedSql && selectNestLevel > 1 )) {
in_operator_sub_select_stmt();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else {
break _loop1659;
}
} while (true);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
compare_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = compare_expr_AST;
}
/**
* Qualifying 3rd expression for the <code>BETWEEN</code> operator.
*/
public final void and_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast and_expr_AST = null;
try { // for error handling
Aast tmp1472_AST = null;
tmp1472_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1472_AST);
match(KW_AND);
sum_expr();
astFactory.addASTChild(currentAST, returnAST);
and_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = and_expr_AST;
}
/**
* Matches <code>ESCAPE</code> keyword and a following string literal
* for the <code>LIKE</code> operator.
*/
public final void escape_char() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast escape_char_AST = null;
try { // for error handling
Aast tmp1473_AST = null;
tmp1473_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1473_AST);
match(KW_ESCAPE);
Aast tmp1474_AST = null;
tmp1474_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1474_AST);
match(STRING);
escape_char_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = escape_char_AST;
}
/**
* Implements the 7th precedence level of Progress 4GL expressions, the
* <code>MULTIPLY</code>, <code>DIVIDE</code> and <code>KW_MOD</code>
* operators.
* <p>
* This is only called by the 5th level {@link #sum_expr} rule. This
* method subsequently calls the {@link #un_type} rule.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
* <p>
* Note that ANTLR reports ambiguity between this rule and the {@link #assign}
* rule. The ambiguity is resolved by the ordering of the top level rule
* placing the <code>ASSIGN</code> language statement (which is unambiguous)
* with higher precedence than the <code>assignment</code> rule. As long as
* the <code>assign</code> rule is only used by the <code>assign_stmt</code>
* rule, there is no real ambiguity. For this reason, ambiguity warnings
* are suppressed for this rule.
*/
public final void prod_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast prod_expr_AST = null;
try { // for error handling
un_type();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1669:
do {
if ((LA(1)==KW_MOD||LA(1)==MULTIPLY||LA(1)==DIVIDE) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case MULTIPLY:
{
Aast tmp1475_AST = null;
tmp1475_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1475_AST);
match(MULTIPLY);
break;
}
case DIVIDE:
{
Aast tmp1476_AST = null;
tmp1476_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1476_AST);
match(DIVIDE);
break;
}
case KW_MOD:
{
Aast tmp1477_AST = null;
tmp1477_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1477_AST);
match(KW_MOD);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
matchAssign = false;
un_type();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1669;
}
} while (true);
}
prod_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = prod_expr_AST;
}
/**
* Implements the 8th precedence level of Progress 4GL expressions, the
* unary operators <code>PLUS</code> and <code>MINUS</code>. This rule is
* different in structure from the previous levels, as the operator is
* leftmost and optional. There is always a right operand.
* <p>
* In any case where the programmer did not use intervening whitespace
* between the operator and a literal value (integer or decimal), the
* lexer will have already included that sign character in the text of
* the literal's token. So this rule would not apply. This rule can only
* be encountered when there is a separate operator token in the token stream
* which only occurs in the absence of whitespace. Since postfixed unary
* operators can only occur on literals and then only without intervening
* whitespace, this rule never has to match on a postfixed unary operator.
* <p>
* This is only called by the 6th level {@link #prod_expr} rule. This
* method subsequently calls the {@link #primary_expr} rule.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
*/
public final void un_type() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast un_type_AST = null;
Token m = null;
Aast m_AST = null;
Token p = null;
Aast p_AST = null;
Aast l_AST = null;
Token eq = null;
Aast eq_AST = null;
Aast e_AST = null;
try { // for error handling
boolean realAssign = false;
boolean lstmt = false;
if (isLstmt(LA(1)) && LA(2) == LPARENS)
{
lstmt = true;
}
{
if (((LA(1)==MINUS))&&(
!(allowStringMatch &&
LA(2) == MINUS) &&
(followedByWhitespace(LT(1)) ||
LA(2) == LPARENS)
)) {
m = LT(1);
m_AST = (Aast)astFactory.create(m);
astFactory.makeASTRoot(currentAST, m_AST);
match(MINUS);
m_AST.setType( UN_MINUS ); matchAssign = false;
}
else if (((LA(1)==PLUS))&&(
!(allowStringMatch &&
LA(2) == PLUS) &&
(followedByWhitespace(LT(1)) ||
LA(2) == LPARENS)
)) {
p = LT(1);
p_AST = (Aast)astFactory.create(p);
astFactory.makeASTRoot(currentAST, p_AST);
match(PLUS);
p_AST.setType( UN_PLUS ); matchAssign = false;
}
else if ((_tokenSet_85.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
chained_object_members();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==EQUALS) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( matchAssign && isLvalue(l_AST) )) {
eq = LT(1);
eq_AST = (Aast)astFactory.create(eq);
astFactory.makeASTRoot(currentAST, eq_AST);
match(EQUALS);
eq_AST.setType(ASSIGN);
realAssign = true;
matchAssign = false;
// we need to decrement exprLvl so that the r-value will have a chance to wrap in
// EXPRESSION.
exprLvl--;
if (l_AST.getType() == COM_INVOCATION && l_AST.getChildAt(1).getType() == COM_METHOD)
{
l_AST.getChildAt(1).setType(COM_PROPERTY);
}
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// this is an assignment, so no need to wrap the assignment's 'expr' call in an
// EXPRESSION node; we need to mark this flag to know the ASSIGNMENT doesn't need
// an EXPRESSION child
skipExpression = true;
if (lstmt)
{
restoreAssignStyleStmt(l_AST);
}
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
if (realAssign && !lstmt)
{
restoreEqualsOperator(l_AST, eq_AST);
}
un_type_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = un_type_AST;
}
/**
* Implements the 10th and highest precendence level of Progress 4GL expressions, the parenthesis
* precedence operators and any all of the common expression constructs ("terms"). The following
* are supported (in this order):
* <p>
* <ol>
* <li> {@link #literal}
* <li> {@link #new_phrase}
* <li> {@link #sql_aggregate_funcs}
* <li> {@link #seek_func}
* <li> {@link #cast_func}
* <li> {@link #type_of_func}
* <li> {@link #sequence_funcs}
* <li> {@link #dynamic_function_func}
* <li> {@link #frame_funcs}
* <li> {@link #record_funcs}
* <li> {@link #func_call}
* <li> {@link #method_call}
* <li> {@link #class_event}
* <li> {@link #user_defined_type_name}
* <li> {@link #accum_function}
* <li> {@link #can_find_function}
* <li> {@link #lvalue}
* <li> {@link #postfix_funcs}
* <li> {@link #if_func}
* <li> {@link #super_function}
* </ol>
* <p>
* Progress has several unusual functions that don't parenthesize parameters
* (e.g. available or ambiguous) and sometimes the function names are even
* postfixed after the first parameter (entered or not entered)! This
* design requires that such functions have hard coded matching rules that
* are called from here.
* <p>
* This rule is different in structure from the previous levels, as the
* there is just a set of alternatives and one of them allows direct recursion
* back to the top level <code>expr</code> expression entry point.
* <p>
* Due to the nature of the <code>func_call</code> and <code>lvalue</code>
* rules, there is an inherent ambiguity since either of these can be
* comprised of a user-defined symbol. We use 2 tricks to resolve this
* ambiguity:
* <ul>
* <li> Both rule references must specify a match with the full set of
* possible token types that can be seen as user-defined symbols.
* This is done by referencing a common {@link #symbol} rule. This
* rule reference generates the proper lookahead code in the top
* level parser rules, such that these rules will be triggered
* when necessary. By placing the more specific of the two rules
* <code>func_call</code> first, the lack of a match on the
* subsequent parenthesis causes processing to drop through to
* <code>lvalue</code>, resolving the ambiguity generated by the
* need to have a common reference to the <code>symbol</code> rule.
* It is most important to understand that without this common rule
* reference, the generated lookahead code would be incorrect and
* these rules would not work.
* <li> When these rules are properly matched by lookahead, the symbol
* token types are rewritten to match the function or variable
* types that are required by the respective rules. This is critical
* to allowing expression evaluation to occur, otherwise there would
* be no real record of the proper token type (be it an lvalue or
* function call). In addition, these token types are data type
* specific (e.g. there is a type for <code>VAR_INT</code>,
* <code>VAR_LOGICAL</code> and all other variable data types).
* </ul>
* <p>
* <code>method_call</code> is similar to <code>func_call</code> and is
* disambiguated from <code>lvalue</code> and <code>func_call</code> with a
* semantic predicate that does a method name lookup.
* <p>
* Similar to the problems with <code>lvalue</code> and <code>func_call</code>
* <code>record_funcs</code> are also ambiguous since there is a
* {@link #record} which is required in the leftmost token when dealing with
* a postfixed function name. This ambiguity is resolved by a query to the
* schema namespace in a semantic predicate. If the symbol is a record, the
* record rule is matched, otherwise it is bypassed.
* <p>
* This is only called by the 8th level {@link #chained_object_members} rule.
* <p>
* See the top level expression parsing rule {@link #expr} for more details.
* <p>
* ANTLR will detect ambiguity between many of these alternatives. This has
* been determined to be non-ambiguous for the Progress domain so ambiguity
* warnings have been disabled.
*/
public final void primary_expr() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast primary_expr_AST = null;
Aast q_AST = null;
Aast l_AST = null;
Aast p1_AST = null;
Aast p2_AST = null;
try { // for error handling
boolean connected = false;
boolean isStatic = false;
String nextTxt = LT(1).getText();
// fixup the LT(1) by discarding the crap and putting the last token
// back together
if (isMalformedSymbolFuncCall())
{
nextTxt = reassembleMalformedSymbol();
}
// the connected built-in can match an unquoted dbname that can
// appear as a symbol (but we can't JUST match on that since it
// can also be a var which appears here as a symbol token), so we
// temporarily enable symbol matching in the lvalue rule
if (LA(1) == KW_CONN_ED && LA(2) == LPARENS)
{
connected = true;
allowSymbolMatch = true;
}
{
if ((_tokenSet_65.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
literal();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_NEW) && (_tokenSet_0.member(LA(2))) && (LA(3)==PLUS||LA(3)==LPARENS))&&(
LA(2) != LPARENS &&
(!sym.isTable(LT(2).getText()) || sym.canLoadClass(LT(2).getText()))
)) {
new_phrase();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_GETCLASS) && (LA(2)==LPARENS) && (_tokenSet_0.member(LA(3))))&&(
LA(2) == LPARENS && sym.isBuiltinFunction(nextTxt)
)) {
get_class_func();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_248.member(LA(1))) && (LA(2)==LPARENS) && (_tokenSet_152.member(LA(3))))&&( embeddedSql )) {
sql_aggregate_funcs();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_SEEK) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
seek_func();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CAST) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
cast_func();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_TYPE_OF) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
type_of_func();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CUR_VAL||LA(1)==KW_NEXT_VAL) && (LA(2)==LPARENS) && (_tokenSet_15.member(LA(3)))) {
sequence_funcs();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_DYN_FUNC) && (LA(2)==LPARENS) && (_tokenSet_24.member(LA(3)))) {
dynamic_function_func();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_249.member(LA(1))) && (LA(2)==LPARENS) && ((LA(3) >= FILEROOT && LA(3) <= JUNK))) {
frame_funcs();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_250.member(LA(1))) && (_tokenSet_251.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
(LA(1) != KW_ERROR &&
LA(1) != KW_ROWID &&
LA(1) != KW_REJECTED &&
LA(1) != KW_ROW_STAT &&
LA(1) != KW_DATA_SM &&
LA(1) != KW_REC_LEN) || LA(2) == LPARENS
)) {
record_funcs();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_252.member(LA(1))) && (LA(2)==LPARENS) && (_tokenSet_79.member(LA(3))))&&(
!evaluatingExpression &&
LA(1) != KW_DYN_NEW &&
LA(1) != KW_SUPER &&
((LA(1) >= BEGIN_OO_METH && LA(1) <= END_OO_METH) ||
sym.isObjectMethod(null, nextTxt, inStaticCtxt))
)) {
method_call(null, inStaticCtxt, false);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_253.member(LA(1))) && (LA(2)==LPARENS) && (_tokenSet_79.member(LA(3))))&&(
(LA(1) >= BEGIN_FUNCTYPES && LA(1) <= END_FUNCTYPES) ||
(LA(1) != KW_DYN_NEW && sym.lookupFunction(nextTxt) != -1)
)) {
func_call();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_254.member(LA(1))) && (LA(2)==COLON) && (LA(3)==KW_PUBLISH||LA(3)==KW_SUBSCRIB||LA(3)==KW_UNSUBSCR))&&(
LA(1) == CLASS_EVENT ||
((inStaticCtxt && (sym.lookupDataMember(null, nextTxt, true) == CLASS_EVENT)) ||
(!inStaticCtxt && (sym.lookupDataMember(null, nextTxt) == CLASS_EVENT)))
)) {
isStatic = sym.isStaticDataMember(null, nextTxt);
class_event(null, isStatic);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!evaluatingExpression &&
LA(1) != KW_DYN_NEW &&
LA(1) != KW_SUPER &&
!isQualifiedFieldNameQuirk(LT(1), LT(2), LT(3)) &&
((inStaticCtxt && (sym.lookupDataMember(null, nextTxt, true) != -1)) ||
(!inStaticCtxt && (sym.lookupDataMember(null, nextTxt) != -1)))
)) {
isStatic = sym.isStaticDataMember(null, nextTxt);
object_data_member(null, isStatic);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_0.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
!evaluatingExpression &&
LA(1) != KW_DYN_NEW &&
LA(1) != KW_SUPER &&
!isQualifiedFieldNameQuirk(LT(1), LT(2), LT(3)) &&
sym.lookupVariable(nextTxt) == -1 &&
!(sym.isField(nextTxt) && LA(2) != COLON) &&
!(LA(1) == KW_BUFFER && sym.isTable(LT(2).getText())) &&
sym.canLoadClass(nextTxt)
)) {
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_ACCUM) && (_tokenSet_24.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
accum_function();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_CAN_FIND) && (LA(2)==LPARENS) && (_tokenSet_255.member(LA(3)))) {
can_find_function();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((LA(1)==KW_SUPER) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(2) != COLON )) {
super_function();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
lvalue();
q_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
(q_AST.getType() == KW_FRAME || q_AST.getType() == KW_BROWSE) &&
((sym.lookupVariable(LT(1).getText()) != -1) ||
(sym.isField(LT(1).getText())))
)) {
lvalue();
l_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==KW_NOT||LA(1)==KW_ENTERED) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
(LA(1) == KW_NOT && LA(2) == KW_ENTERED) ||
(LA(1) == KW_ENTERED)
)) {
postfix_funcs();
p1_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if (((LA(1)==KW_NOT||LA(1)==KW_ENTERED) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&(
(LA(1) == KW_NOT && LA(2) == KW_ENTERED) ||
(LA(1) == KW_ENTERED)
)) {
postfix_funcs();
p2_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
else if ((LA(1)==KW_IF) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
if_func();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==LPARENS)) {
Aast tmp1478_AST = null;
tmp1478_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1478_AST);
match(LPARENS);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
primary_expr_AST = (Aast)currentAST.root;
if (connected)
{
allowSymbolMatch = false;
}
// rewrite entered/not entered to match normal func call
if (p1_AST != null || p2_AST != null)
{
Aast post = (p1_AST != null ? p1_AST : p2_AST);
// attach the main lvalue
q_AST.setNextSibling(null);
post.setFirstChild(q_AST);
// avoid infinite loops in tree building ops, so we "do it
// ourselves"
if (l_AST != null)
{
l_AST.setNextSibling(null);
q_AST.setNextSibling(l_AST);
}
primary_expr_AST = post;
}
currentAST.root = primary_expr_AST;
currentAST.child = primary_expr_AST!=null &&primary_expr_AST.getFirstChild()!=null ?
primary_expr_AST.getFirstChild() : primary_expr_AST;
currentAST.advanceChildToEnd();
primary_expr_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = primary_expr_AST;
}
/**
* Helper rule to match a {@link #method_call}, {@link #class_event} or an
* {@link #object_data_member} in a {@link #chained_object_members}. This
* rule will match one or the other and will disambiguate the two based on
* a lookup of the method name in the given class' namespace. This method
* MUST ONLY be used from the 3rd-most token from the left of the expression
* (or further right than that) since it uses {@link #any_symbol_at_all} to
* pull even reserved keywords into this rule and then it rewrites the token
* types before lookahead picks the subrules. This allows the subrules to
* be common code that are also called from {@link #primary_expr} (where they
* are not allowed to match with reserved keywords, even in Progress, and doing
* so would hose the parser bigtime).
*
* @param cls
* Class name containing the members for which to search.
* @param isStatic
* <code>true</code> if this is a static reference.
* @param isSuper
* <code>true</code> if the rvalue refnode is the SUPER keyword.
*/
public final void downstream_chained_reference(
String cls, boolean isStatic, boolean isSuper
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast downstream_chained_reference_AST = null;
try { // for error handling
CommonToken tok = (CommonToken) LT(1);
String txt = tok.getText();
int type = tok.getType();
boolean unquoted = false;
int newtype = -1;
boolean methodLookup = false;
boolean instanceDataLookup = false;
boolean staticDataLookup = false;
boolean prevChain = sym.isChainedReference();
sym.setChainedReference(true);
boolean remove = false;
// special unquoted method name matching case
if (insideClassEvent && LA(2) != LPARENS)
{
if (sym.isObjectMethod(cls, txt, isStatic))
{
newtype = SYMBOL;
unquoted = true;
}
}
if (newtype == -1)
{
// for a method name, LA(2) must be an LPARENS
if (LA(2) == LPARENS)
{
methodLookup = true;
// instance-qualified members can be static or instance, class-qualified members
// can only be static
newtype = sym.lookupObjectMethod(cls, txt, isStatic);
}
// there are possible constructs where an expression can be used in a language
// statement and the following LPARENS is not related to a method call but instead
// there is a data member being referenced; for example:
// RUN proc IN this-object:var (INPUT some-run-stmt-param).
// for this reason, we have checked the method case first, but if it did not match
// then we need to check the data members even though LA(2) is LPARENS
if (newtype == -1)
{
if (!isStatic)
{
instanceDataLookup = true;
// instance-qualified members can be static or instance
newtype = sym.lookupDataMember(cls, txt);
}
else
{
staticDataLookup = true;
// class-qualified members can only be static
newtype = sym.lookupDataMember(cls, txt, true);
}
}
}
sym.setChainedReference(prevChain);
// if we have to rewrite, do it here
if ((newtype >= BEGIN_OO_METH && newtype <= END_OO_METH) ||
(newtype >= BEGIN_VARTYPES && newtype <= END_VARTYPES) ||
newtype == CLASS_EVENT ||
newtype == SYMBOL)
{
tok.setType(newtype);
}
else
{
System.out.printf("Lookup of %s (%s) in %s (static = %b) failed; attempted method %b, " +
"instance data %b, static data %b;\n",
txt,
lookupTokenName(type),
cls,
isStatic,
methodLookup,
instanceDataLookup,
staticDataLookup);
// must be an unreserved keyword, reserved keyword, DB_SYMBOL,
// FILENAME, BOOL_FALSE or BOOL_TRUE that is not recognized as a
// class member
throw new NoViableAltException(tok, getFilename());
}
{
if (((LA(1)==SYMBOL) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( unquoted )) {
Aast tmp1479_AST = null;
tmp1479_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1479_AST);
match(SYMBOL);
}
else if (((_tokenSet_252.member(LA(1))) && (LA(2)==LPARENS) && (_tokenSet_79.member(LA(3))))&&( LA(1) >= BEGIN_OO_METH && LA(1) <= END_OO_METH )) {
method_call(cls, isStatic, isSuper);
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_254.member(LA(1))) && (LA(2)==COLON) && (LA(3)==KW_PUBLISH||LA(3)==KW_SUBSCRIB||LA(3)==KW_UNSUBSCR))&&( LA(1) == CLASS_EVENT )) {
class_event(cls, isStatic);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
object_data_member(cls, isStatic);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
any_symbol_at_all();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
downstream_chained_reference_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = downstream_chained_reference_AST;
}
/**
* Matches COM method and property references, their optional parenthesized parameters list. Uses recursion
* to support chaining. The result will be rooted at a <code>COM_METHOD</code> or <code>COM_PROPERTY</code>
* node. Any parameters will be direct children using the {@link #com_parameter}, the parenthesis and commas
* will be dropped. This rule rewrites the token type of the first token, as it will be a symbol or reserved
* keyword on entry. That first token is the method or property name and the original token type will be
* saved in the <code>oldtype</code> annotation.
* <p>
* The {@link #reserved_or_symbol} rule is used to "pull" processing down this path but it never will be
* matched due to the token rewriting. If a 2nd token of <code>LPARENS</code> is seen, then the result will
* be a <code>COM_METHOD</code>, even if this is really an indexed property which uses a parenthesized list
* of integer expressions as an index, one per array dimension. This is a flaw which cannot be resolved
* without information not available in the source code. So those indexed properties will have to be
* disambiguated from methods by some later process.
* <p>
* The 4GL allows a string literal to be used in place of a COM property name or COM method name. This only
* works on a COM-HANDLE and not on a regular HANDLE referent. The STRING token is never matched at runtime
* since the type is overwritten, but it is used for "pull" processing. This is an undocumented feature of
* the 4GL.
* <p>
* There are COM property and method names that are documented in the language reference. These have some
* special meaning or importance and thus they are given better support than the unknown interfaces in the
* controls that are used (such interfaces are only known on systems in which those controls are
* registered). In our case one can find the following token types set into the <code>oldtype</code>
* annotation of a <code>COM_PROPERTY</code> or <code>COM_METHOD</code>. The following are supported:
* <p>
* <pre>
* Token Type Name Type
* --------------- -------------------------- --------------------
* KW_CNTRL_NM Control-Name Property
* KW_CONTROLS Controls Property
* KW_HEIGHT_C Height Property
* KW_HONOR_PK HonorProKeys Property
* KW_HONOR_RK HonorReturnKey Property
* KW_LEFT Left Property
* KW_LOADCTRL LoadContols Method
* KW_NAME Name Property
* KW_TAG Tag Property
* KW_TOP Top Property
* KW_WID_HAND Widget-Handle Property
* KW_WIDTH Width Property
* </pre>
*/
public final void com_property_or_method() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast com_property_or_method_AST = null;
try { // for error handling
int oldtype = -1;
int current = LA(1);
if (current != COM_METHOD && current != COM_PROPERTY)
{
int newtype = (LA(2) == LPARENS) ? COM_METHOD : COM_PROPERTY;
// save off old type
oldtype = current;
// set the type
LT(1).setType(newtype);
}
{
{
switch ( LA(1)) {
case COM_METHOD:
{
Aast tmp1480_AST = null;
tmp1480_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1480_AST);
match(COM_METHOD);
break;
}
case COM_PROPERTY:
{
Aast tmp1481_AST = null;
tmp1481_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1481_AST);
match(COM_PROPERTY);
{
if ((LA(1)==LBRACKET) && ((LA(2) >= DOT && LA(2) <= JUNK)) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
subscript();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case STRING:
{
Aast tmp1482_AST = null;
tmp1482_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1482_AST);
match(STRING);
break;
}
default:
if ((_tokenSet_27.member(LA(1)))) {
reserved_or_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LPARENS) && (_tokenSet_80.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_80.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
com_parameter();
astFactory.addASTChild(currentAST, returnAST);
{
_loop1748:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
com_parameter();
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1748;
}
} while (true);
}
}
else if ((LA(1)==RPARENS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
com_property_or_method_AST = (Aast)currentAST.root;
// save off original type from before token rewriting
if (oldtype != -1)
com_property_or_method_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
com_property_or_method_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = com_property_or_method_AST;
}
/**
* Matches an optional widget qualifier using the keyword <code>IN</code>.
* Calls the {@link #frame_reference}, {@link #lvalue} (for browse) and
* {@link #menu_reference} rules. Roots the tree at the <code>IN</code>.
* <p>
* Used by <code>lvalue</code> and the recursive call to <code>lvalue</code>
* is protected by a semantic predicate keyed off of <code>KW_BROWSE</code>.
* <p>
* Uses a flag to allow a match for the <code>IN prochandle</code> using
* {@link #expr} for matching when called from rules which can ambiguously
* match both this clause and a following expression.
*/
public final void widget_qualifier() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast widget_qualifier_AST = null;
try { // for error handling
Aast tmp1483_AST = null;
tmp1483_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1483_AST);
match(KW_IN);
{
if ((LA(1)==KW_FRAME) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
frame_reference(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((LA(1)==KW_MENU||LA(1)==KW_SUB_MENU) && (_tokenSet_15.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
menu_reference();
astFactory.addASTChild(currentAST, returnAST);
}
else if (((_tokenSet_64.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( LA(1) == KW_BROWSE )) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
widget_qualifier_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = widget_qualifier_AST;
}
/**
* Match <code>LPARENS expr RPARENS</code> which is valid (undocumented) syntax for specifying
* the subscript on an extent field when used in a <code>DB_REF_NON_STATIC</code> construct.
* The <code>RPARENS</code> is dropped and the <code>expr</code> is rooted at the
* <code>LPARENS</code>.
*/
public final void lparens_subscript() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast lparens_subscript_AST = null;
try { // for error handling
Aast tmp1484_AST = null;
tmp1484_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1484_AST);
match(LPARENS);
expr();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
lparens_subscript_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = lparens_subscript_AST;
}
/**
* Matches all Progress 4GL method calls and their parenthesized parameter
* lists.
* <p>
* The matching portion of this rule comes in 2 parts:
* <ul>
* <li> The leftmost token is the method name. This is defined as the
* union of the set of all method token types (one for each return
* data type, e.g. <code>OO_METH_INT</code>) and the set of all possible
* alternatives for symbol names (a reference to the
* {@link #any_non_reserved_symbol}. Although all reserved keywords can
* be used as method names, this use of all possible keywords would
* create huge ambiguity if allowed in the leftmost token of an
* expression. This rule can be called in such a location for a
* "standalone" method call (within the class in which it is
* defined). However, in that case Progress disallows matching with
* reserved keywords, so one must use the class name (for static
* events) or THIS-OBJECT (for instance events) as a qualifier.
* That is why this rule doesn't "pull" the reserved keywords. The
* {@link #downstream_chained_reference} does include reserved
* keywords and it does call this rule. However, it rewrites the
* token types up front so that the lookahead won't break.
* <li> The next part is the {@link #func_call_parameters}.
* </ul>
* <p>
* It is required that where this rule is referenced as one alternative that
* conflicts with the definitions of other alternatives (see
* {@link #primary_expr} and {@link #lvalue}), <b>the order of the
* alternatives must be more specific (in terms of matching criteria) to less
* specific</b>. Since the <code>method_call</code> rule contains the very
* specific <code>symbol</code> followed by <code>LPARENS</code> pattern,
* it is more specific than a simple <code>symbol</code> by itself (which is
* the definition of an <code>lvalue</code>. For this reason,
* <code>func_call</code> must always be placed ahead of <code>lvalue</code>
* in alternative lists.
* <p>
* The inclusion of the <code>any_symbol_at_all</code> rule ensures that all
* valid symbols that are followed by an <code>LPARENS</code> are considered a
* method call and will be matched by this rule. This means that the
* top level expression processing will include a symbol as one of the options
* for its leftmost token, thus "pulling" the recursive descent
* processing down the <code>expr</code> rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> since this could be anything. What we
* really require is a leftmost token that is one of the valid function
* tokens:
* <pre>
* 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_INT
* OO_METH_INT64
* OO_METH_HANDLE
* OO_METH_LOGICAL
* OO_METH_LONGCHAR
* OO_METH_MEMPTR
* OO_METH_RAW
* OO_METH_RECID
* OO_METH_ROWID
* OO_METH_POLY
* OO_METH_VOID
* </pre>
* <p>
* There is ambiguity between this rule and the {@link #func_call} rule
* which is resolved by semantic predicates that use the next token's text
* to determine if there is a match to a function or method call.
* <p>
* All methods have a token type associated with their respective return
* value. Some built-in method may have the special type of
* <code>OO_METH_POLY</code>. This special type indicates that the method can
* return multiple different return types. <code>OO_METH_VOID</code> is a
* special type which returns no value.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
*
* @param cls
* Fully qualified name of the class being referenced or
* <code>null</code> if this is within the current class
* definition.
* @param isStatic
* <code>true</code> if this is a static reference.
* @param isSuper
* <code>true</code> if the rvalue refnode is the SUPER keyword.
*/
public final void method_call(
String cls, boolean isStatic, boolean isSuper
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast method_call_AST = null;
try { // for error handling
int oldtype = -1;
int current = LA(1);
String methname = LT(1).getText();
if (current < BEGIN_OO_METH || current > END_OO_METH)
{
// this is just a guess until we have the parameters parsed below, if the type is
// wrong it will be fixed when we annotate
int newtype = sym.lookupObjectMethod(cls, methname, isStatic);
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if (newtype != -1)
{
oldtype = LA(1);
LT(1).setType(newtype);
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case OO_METH_CHAR:
{
Aast tmp1485_AST = null;
tmp1485_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1485_AST);
match(OO_METH_CHAR);
break;
}
case OO_METH_CLASS:
{
Aast tmp1486_AST = null;
tmp1486_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1486_AST);
match(OO_METH_CLASS);
break;
}
case OO_METH_COM_HANDLE:
{
Aast tmp1487_AST = null;
tmp1487_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1487_AST);
match(OO_METH_COM_HANDLE);
break;
}
case OO_METH_DATE:
{
Aast tmp1488_AST = null;
tmp1488_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1488_AST);
match(OO_METH_DATE);
break;
}
case OO_METH_DATETIME:
{
Aast tmp1489_AST = null;
tmp1489_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1489_AST);
match(OO_METH_DATETIME);
break;
}
case OO_METH_DATETIME_TZ:
{
Aast tmp1490_AST = null;
tmp1490_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1490_AST);
match(OO_METH_DATETIME_TZ);
break;
}
case OO_METH_DEC:
{
Aast tmp1491_AST = null;
tmp1491_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1491_AST);
match(OO_METH_DEC);
break;
}
case OO_METH_HANDLE:
{
Aast tmp1492_AST = null;
tmp1492_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1492_AST);
match(OO_METH_HANDLE);
break;
}
case OO_METH_INT:
{
Aast tmp1493_AST = null;
tmp1493_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1493_AST);
match(OO_METH_INT);
break;
}
case OO_METH_INT64:
{
Aast tmp1494_AST = null;
tmp1494_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1494_AST);
match(OO_METH_INT64);
break;
}
case OO_METH_LOGICAL:
{
Aast tmp1495_AST = null;
tmp1495_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1495_AST);
match(OO_METH_LOGICAL);
break;
}
case OO_METH_LONGCHAR:
{
Aast tmp1496_AST = null;
tmp1496_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1496_AST);
match(OO_METH_LONGCHAR);
break;
}
case OO_METH_MEMPTR:
{
Aast tmp1497_AST = null;
tmp1497_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1497_AST);
match(OO_METH_MEMPTR);
break;
}
case OO_METH_RAW:
{
Aast tmp1498_AST = null;
tmp1498_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1498_AST);
match(OO_METH_RAW);
break;
}
case OO_METH_RECID:
{
Aast tmp1499_AST = null;
tmp1499_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1499_AST);
match(OO_METH_RECID);
break;
}
case OO_METH_ROWID:
{
Aast tmp1500_AST = null;
tmp1500_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1500_AST);
match(OO_METH_ROWID);
break;
}
case OO_METH_POLY:
{
Aast tmp1501_AST = null;
tmp1501_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1501_AST);
match(OO_METH_POLY);
break;
}
case OO_METH_VOID:
{
Aast tmp1502_AST = null;
tmp1502_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1502_AST);
match(OO_METH_VOID);
break;
}
default:
if ((_tokenSet_53.member(LA(1)))) {
any_non_reserved_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
func_call_parameters(false);
astFactory.addASTChild(currentAST, returnAST);
method_call_AST = (Aast)currentAST.root;
// save any original token type that rewriting may have erased
if (oldtype != -1)
method_call_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
// this leaves notes behind regarding the called method
sym.annotateObjectMethod(cls, methname, isStatic, isSuper, method_call_AST);
method_call_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = method_call_AST;
}
/**
* Matches all Progress 4GL class event references and the usage of the publish,
* subscribe and unsubscribe methods.
* <p>
* The matching portion of this rule comes in 3 parts:
* <ul>
* <li> The leftmost token is the event name. This is defined as the
* {@link #any_non_reserved_symbol}. Although all reserved keywords can
* be used as class events, this use of all possible keywords would
* create huge ambiguity if allowed in the leftmost token of an
* expression. This rule can be called in such a location for a
* "standalone" event reference (within the class in which it is
* defined). However, in that case Progress disallows matching with
* reserved keywords, so one must use the class name (for static
* events) or THIS-OBJECT (for instance events) as a qualifier.
* That is why this rule doesn't "pull" the reserved keywords. The
* {@link #downstream_chained_reference} does include reserved
* keywords and it does call this rule. However, it rewrites the
* token types up front so that the lookahead won't break.
* <li> The next part is the <code>COLON</code> followed by one of the
* keywords <code>KW_PUBLISH</code>, <code>KW_SUBSCRIB</code> or
* <code>KW_UNSUBSCR</code>.
* <li> The <code>KW_PUBLISH</code> case is followed by
* {@link #func_call_parameters}.
* <li> The <code>KW_SUBSCRIB</code> and <code>KW_UNSUBSCR</code> cases have
* common matching logic. They are always followed by an
* <code>LPARENS</code>. Inside the parenthesis can be an
* optional {@link #expr} plus <code>COLON</code> and then an
* <code>any_symbol_at_all</code> unquoted method name reference.
* The other alternative inside the parenthesis is an <code>expr</code>
* followed by an optional <code>COMMA</code> plus <code>expr</code>.
* At the end is always an <code>RPARENS</code>.
* </ul>
* <p>
* It is required that where this rule is referenced as one alternative that
* conflicts with the definitions of other alternatives (see
* {@link #primary_expr} and {@link #lvalue}), <b>the order of the
* alternatives must be more specific (in terms of matching criteria) to less
* specific</b>. For this reason, this rule must always be placed ahead of
* <code>lvalue</code> in alternative lists.
* <p>
* The inclusion of the <code>any_symbol_at_all</code> rule ensures that all
* valid symbols that are followed by an <code>LPARENS</code> are considered a
* method call and will be matched by this rule. This means that the
* top level expression processing will include a symbol as one of the options
* for its leftmost token, thus "pulling" the recursive descent
* processing down the <code>expr</code> rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> since this could be anything. What we
* really require is a leftmost token that is <code>CLASS_EVENT</code>.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
*
* @param cls
* Fully qualified name of the class being referenced or
* <code>null</code> if this is within the current class
* definition.
* @param isStatic
* <code>true</code> if this is a static reference.
*/
public final void class_event(
String cls, boolean isStatic
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast class_event_AST = null;
Token evt = null;
Aast evt_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
String oldClassName = currentClassName;
currentClassName = cls;
boolean oldStaticFlag = currentStaticFlag;
currentStaticFlag = isStatic;
int oldtype = -1;
int current = LA(1);
String evtname = LT(1).getText();
if (current != CLASS_EVENT)
{
int newtype = sym.lookupDataMember(cls, evtname, isStatic);
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if (newtype == CLASS_EVENT)
{
oldtype = LA(1);
LT(1).setType(newtype);
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
{
if ((LA(1)==CLASS_EVENT)) {
evt = LT(1);
evt_AST = (Aast)astFactory.create(evt);
astFactory.addASTChild(currentAST, evt_AST);
match(CLASS_EVENT);
annotateVariable(evt_AST.getText(), CLASS_EVENT, evt_AST);
}
else if ((_tokenSet_53.member(LA(1)))) {
any_non_reserved_symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(COLON);
c_AST.setType(OBJECT_INVOCATION);
{
switch ( LA(1)) {
case KW_PUBLISH:
{
Aast tmp1503_AST = null;
tmp1503_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1503_AST);
match(KW_PUBLISH);
func_call_parameters(false);
astFactory.addASTChild(currentAST, returnAST);
class_event_AST = (Aast)currentAST.root;
sym.annotateObjectEvent(evt_AST, class_event_AST, inStaticCtxt);
break;
}
case KW_SUBSCRIB:
case KW_UNSUBSCR:
{
{
{
switch ( LA(1)) {
case KW_SUBSCRIB:
{
Aast tmp1504_AST = null;
tmp1504_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1504_AST);
match(KW_SUBSCRIB);
break;
}
case KW_UNSUBSCR:
{
Aast tmp1505_AST = null;
tmp1505_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1505_AST);
match(KW_UNSUBSCR);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if (((_tokenSet_1.member(LA(1))) && (LA(2)==RPARENS) && (_tokenSet_3.member(LA(3))))&&(
(LA(1) >= BEGIN_OO_METH && LA(1) <= END_OO_METH) ||
sym.isObjectMethod(null, LT(1).getText(), inStaticCtxt)
)) {
any_symbol_at_all();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
insideClassEvent = true;
expr();
astFactory.addASTChild(currentAST, returnAST);
insideClassEvent = false;
{
switch ( LA(1)) {
case COMMA:
{
comma();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
// save any original token type that rewriting may have erased
if (oldtype != -1)
evt_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
currentClassName = oldClassName;
currentStaticFlag = oldStaticFlag;
class_event_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = class_event_AST;
}
/**
* Matches all Progress 4GL {@link #lvalue} references that exist in the
* namespace of the given class name.
* <p>
* This rule is simply a convenience method to use the current class name
* instance variable to bias the <code>lvalue</code> to lookup data members
* within the given namespace. When done, the flag is set back to its prior
* state.
*
* @param cls
* Class name containing the members for which to search.
* @param isStatic
* <code>true</code> if this is a static reference.
*/
public final void object_data_member(
String cls, boolean isStatic
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast object_data_member_AST = null;
Aast lv_AST = null;
try { // for error handling
String oldClassName = currentClassName;
currentClassName = cls;
boolean oldStaticFlag = currentStaticFlag;
currentStaticFlag = isStatic;
int newtype = -1;
int oldtype = -1;
String txt = LT(1).getText();
// TODO: the following code is duplicated in downstream_chained_reference and we
// should work this into common code
// reserved keywords that match data members as the start of an expression can
// appear here and need to be fixed up before lvalue otherwise they may be interpreted
// as qualifiers or other syntax (e.g. a data member named "query")
if (LA(1) < BEGIN_VARTYPES || LA(1) > END_VARTYPES)
{
if (!isStatic)
{
// instance-qualified members can be static or instance
newtype = sym.lookupDataMember(cls, txt);
}
else
{
// class-qualified members can only be static
newtype = sym.lookupDataMember(cls, txt, true);
}
if (newtype != -1)
{
oldtype = LA(1);
LT(1).setType(newtype);
}
else
{
// must be an unreserved keyword, reserved keyword, DB_SYMBOL,
// FILENAME, BOOL_FALSE or BOOL_TRUE that is not recognized as a
// class member
throw new NoViableAltException(LT(1), getFilename());
}
}
boolean classLookup = sym.isClassLookup();
sym.setClassLookup(true);
lvalue();
lv_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
sym.setClassLookup(classLookup);
currentClassName = oldClassName;
currentStaticFlag = oldStaticFlag;
if (oldtype != -1)
{
lv_AST.putAnnotation("oldtype", (long) oldtype);
}
object_data_member_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = object_data_member_AST;
}
/**
* Matches the <code>NEW</code> phrase in an expression, allowing new object
* instances to be instantiated. Uses {@link #user_defined_type_name} and
* {@link #param_passing_list} and is called from {@link #primary_expr}.
*/
public final void new_phrase() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast new_phrase_AST = null;
Aast udt_AST = null;
try { // for error handling
Aast tmp1506_AST = null;
tmp1506_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1506_AST);
match(KW_NEW);
user_defined_type_name();
udt_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
new_phrase_AST = (Aast)currentAST.root;
// save the original token type, then rewrite the type
new_phrase_AST.putAnnotation("oldtype", Long.valueOf(new_phrase_AST.getType()));
new_phrase_AST.setType(FUNC_CLASS);
// write our function-specific annotations
sym.annotateFunction(new_phrase_AST.getText(), new_phrase_AST, false);
// the above probably did not set the class name so we force it here
String qname = (String) udt_AST.getAnnotation("qualified");
if (qname == null)
{
String err = String.format("Unable to find 'qualified' annotation.");
throw genExc(err, new_phrase_AST);
}
sym.annotateClassRef(qname, new_phrase_AST);
// this leaves notes behind regarding the called ctor
sym.annotateObjectMethod(qname, null, false, new_phrase_AST);
new_phrase_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = new_phrase_AST;
}
/**
* Matches the <code>GET-CLASS(class-name)</code> builtin-function. A separate rule is required to force
* the single argument of this function to be a qualified or unqualified type name.
*/
public final void get_class_func() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast get_class_func_AST = null;
try { // for error handling
Aast tmp1507_AST = null;
tmp1507_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1507_AST);
match(KW_GETCLASS);
lparens();
astFactory.addASTChild(currentAST, returnAST);
user_defined_type_name();
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
get_class_func_AST = (Aast)currentAST.root;
// save the original token type, then rewrite the type
get_class_func_AST.putAnnotation("oldtype", Long.valueOf(get_class_func_AST.getType()));
get_class_func_AST.setType(FUNC_CLASS);
// write our function-specific annotations
sym.annotateFunction(get_class_func_AST.getText(), get_class_func_AST, false);
// the above probably did not set the class name so we force it here
sym.annotateClassRef("Progress.Lang.Class", get_class_func_AST);
get_class_func_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = get_class_func_AST;
}
/**
* Matches the <code>seek()</code> function call. The root node returned
* will be a <code>FUNC_INT</code> and there will be one child which may
* be <code>KW_INPUT</code>, <code>KW_OUTPUT</code> or an expression that
* represents a stream.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter (which can be a complete
* expression subtree or a simple single node like an lvalue) is created
* as a separate child node of the function type token. All parameters are
* maintained as child nodes in the exact order of the function call itself,
* so this is essentially the signature of the function. It it also the
* proper AST definition to enable simple evaluation of functions with any
* arbitrary signature.
* <p>
* The <code>SEEK</code> function can reference the unnamed input or unnamed
* output streams using only the keywords <code>INPUT</code> and
* <code>OUTPUT</code>. This is honored.
*/
public final void seek_func() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast seek_func_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.makeASTRoot(currentAST, s_AST);
match(KW_SEEK);
s_AST.setType(FUNC_INT);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==KW_INPUT) && (LA(2)==RPARENS) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1508_AST = null;
tmp1508_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1508_AST);
match(KW_INPUT);
}
else if ((LA(1)==KW_OUTPUT) && (LA(2)==RPARENS) && (_tokenSet_3.member(LA(3)))) {
Aast tmp1509_AST = null;
tmp1509_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1509_AST);
match(KW_OUTPUT);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
expr();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
seek_func_AST = (Aast)currentAST.root;
// save the original token type that rewriting erased
seek_func_AST.putAnnotation("oldtype", Long.valueOf(KW_SEEK));
// write our function-specific annotations
sym.annotateFunction(s_AST.getText(), seek_func_AST, false);
seek_func_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = seek_func_AST;
}
/**
* Matches the <code>cast()</code> function call. The root node returned
* will be a <code>FUNC_CLASS</code> and there will be an {@link #expr} child
* and a second child of {@link #user_defined_type_name}.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter (which can be a complete
* expression subtree or a simple single node like an lvalue) is created
* as a separate child node of the function type token. All parameters are
* maintained as child nodes in the exact order of the function call itself,
* so this is essentially the signature of the function. It it also the
* proper AST definition to enable simple evaluation of functions with any
* arbitrary signature.
*/
public final void cast_func() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast cast_func_AST = null;
Token c = null;
Aast c_AST = null;
Aast udt_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CAST);
c_AST.setType(FUNC_CLASS);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
user_defined_type_name();
udt_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
cast_func_AST = (Aast)currentAST.root;
// save the original token type that rewriting erased
cast_func_AST.putAnnotation("oldtype", Long.valueOf(KW_CAST));
// write our function-specific annotations
sym.annotateFunction(c_AST.getText(), cast_func_AST, false);
// the above probably did not set the class name so we force it here
String qname = (String) udt_AST.getAnnotation("qualified");
if (qname == null)
{
String err = String.format("Unable to find 'qualified' annotation.");
throw genExc(err, cast_func_AST);
}
sym.annotateClassRef(qname, cast_func_AST);
cast_func_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = cast_func_AST;
}
/**
* Matches the <code>type-of()</code> function call. The root node returned
* will be a <code>FUNC_LOGICAL</code> and there will be an {@link #expr} child
* and a second child of {@link #user_defined_type_name}.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter (which can be a complete
* expression subtree or a simple single node like an lvalue) is created
* as a separate child node of the function type token. All parameters are
* maintained as child nodes in the exact order of the function call itself,
* so this is essentially the signature of the function. It it also the
* proper AST definition to enable simple evaluation of functions with any
* arbitrary signature.
*/
public final void type_of_func() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast type_of_func_AST = null;
Token c = null;
Aast c_AST = null;
Aast udt_AST = null;
try { // for error handling
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_TYPE_OF);
c_AST.setType(FUNC_LOGICAL);
lparens();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
comma();
astFactory.addASTChild(currentAST, returnAST);
user_defined_type_name();
udt_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
type_of_func_AST = (Aast)currentAST.root;
// save the original token type that rewriting erased
type_of_func_AST.putAnnotation("oldtype", Long.valueOf(KW_TYPE_OF));
// write our function-specific annotations
sym.annotateFunction(c_AST.getText(), type_of_func_AST, false);
// the above probably did not set the class name so we force it here
String qname = (String) udt_AST.getAnnotation("qualified");
if (qname == null)
{
String err = String.format("Unable to find 'qualified' annotation.");
throw genExc(err, type_of_func_AST);
}
sym.annotateClassRef(qname, type_of_func_AST);
type_of_func_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = type_of_func_AST;
}
/**
* Matches the <code>dynamic-function()</code> function call. The root node
* returned will be a <code>FUNC_POLY</code> and there will be at least one
* child which would be an expression that names the function to be called.
* This mandatory first parameter many optionally be followed by a
* {@link #in_procedure_clause} and then any number of comma-separated
* parameter expressions.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter (which can be a complete
* expression subtree or a simple single node like an lvalue) is created
* as a separate child node of the function type token. All parameters are
* maintained as child nodes in the exact order of the function call itself,
* so this is essentially the signature of the function. It it also the
* proper AST definition to enable simple evaluation of functions with any
* arbitrary signature.
*/
public final void dynamic_function_func() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast dynamic_function_func_AST = null;
Token d = null;
Aast d_AST = null;
try { // for error handling
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_DYN_FUNC);
d_AST.setType(FUNC_POLY);
inDynFunc = true;
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
func_call_parm(false);
astFactory.addASTChild(currentAST, returnAST);
inDynFunc = false;
{
switch ( LA(1)) {
case KW_IN:
{
in_procedure_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case COMMA:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop1725:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
func_call_parm(false);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1725;
}
} while (true);
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
dynamic_function_func_AST = (Aast)currentAST.root;
// save the original token type that rewriting erased
dynamic_function_func_AST.putAnnotation("oldtype", Long.valueOf(KW_DYN_FUNC));
// write our function-specific annotations
sym.annotateFunction(d_AST.getText(), dynamic_function_func_AST, false);
dynamic_function_func_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = dynamic_function_func_AST;
}
/**
* Matches the frame related function calls that can take a frame name as
* a parameter. The following are supported:
* <p>
* <pre>
* Function Type
* ------------ -------------
* FRAME-COL FUNC_DEC
* FRAME-DOWN FUNC_INT
* FRAME-LINE FUNC_INT
* FRAME-ROW FUNC_DEC
* </pre>
* <p>
* The root node returned will be a <code>FUNC_INT</code> or
* <code>FUNC_DEC</code> and there will be one child node which is a frame
* reference (see {@link #lvalue}) OR it is a <code>SYMBOL</code> that is an
* invalid frame name. Progress silently tolerates such an invalid frame
* name and just returns 0 at runtime. This method is needed because of this
* behavior since an invalid frame reference would not be possible in a
* regular <code>lvalue</code>.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter (which can be a complete
* expression subtree or a simple single node like an lvalue) is created
* as a separate child node of the function type token. All parameters are
* maintained as child nodes in the exact order of the function call itself,
* so this is essentially the signature of the function. It it also the
* proper AST definition to enable simple evaluation of functions with any
* arbitrary signature.
*/
public final void frame_funcs() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast frame_funcs_AST = null;
Token fc = null;
Aast fc_AST = null;
Token fd = null;
Aast fd_AST = null;
Token fl = null;
Aast fl_AST = null;
Token fr = null;
Aast fr_AST = null;
Aast frame_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_FR_COL:
{
fc = LT(1);
fc_AST = (Aast)astFactory.create(fc);
astFactory.makeASTRoot(currentAST, fc_AST);
match(KW_FR_COL);
saveAndReplaceType(fc_AST, FUNC_DEC);
break;
}
case KW_FR_DOWN:
{
fd = LT(1);
fd_AST = (Aast)astFactory.create(fd);
astFactory.makeASTRoot(currentAST, fd_AST);
match(KW_FR_DOWN);
saveAndReplaceType(fd_AST, FUNC_INT);
break;
}
case KW_FR_LINE:
{
fl = LT(1);
fl_AST = (Aast)astFactory.create(fl);
astFactory.makeASTRoot(currentAST, fl_AST);
match(KW_FR_LINE);
saveAndReplaceType(fl_AST, FUNC_INT);
break;
}
case KW_FR_ROW:
{
fr = LT(1);
fr_AST = (Aast)astFactory.create(fr);
astFactory.makeASTRoot(currentAST, fr_AST);
match(KW_FR_ROW);
saveAndReplaceType(fr_AST, FUNC_DEC);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((((LA(1) >= FILEROOT && LA(1) <= JUNK)) && ((LA(2) >= FILEROOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != KW_FRAME )) {
malformed_symbol();
frame_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
// it is possible to pass anything (even a name that isn't
// a frame) so we only convert this if the frame name is valid
if (sym.lookupFrame(frame_AST.getText()) != -1)
{
frame_AST.setType(WID_FRAME);
}
}
else if ((_tokenSet_64.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
lvalue();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
frame_funcs_AST = (Aast)currentAST.root;
// write our function-specific annotations
sym.annotateFunction(frame_funcs_AST.getText(), frame_funcs_AST, false);
frame_funcs_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = frame_funcs_AST;
}
/**
* This rule implements the special built-in functions that can be used
* used in an expression for processing {@link #record} or
* {@link #primary_expr} (a field) but which don't take normal parenthesized
* parameters (the single parameter for each of these is postfixed) or the
* function takes parenthesized parameters but the parameters include a
* <code>record</code> (which is not normally allowed in an expression). The
* <code>INPUT</code> form can have an optional prefixed
* {@link #frame_reference}.
* <p>
* The following are matched:
* <p>
* <pre>
* Function Syntax Optional Parens Notes
* ------------------------------ --------------- ---------------------------
* AVAILABLE record Y
* AMBIGUOUS record Y
* CURRENT-CHANGED record Y
* ERROR( record ) N
* INPUT field N* Parens can be matched in the
* primary_expr rule that is
* used to match the field, but
* it doesn't operate the same
* way as function parens.
* INPUT FRAME frame field N* See INPUT field notes above.
* LOCKED record Y
* NEW record Y
* RECID( record ) N
* RECORD-LENGTH( record ) N
* ROWID( record ) N
* ROW-STATE( record ) N
* </pre>
* <p>
* This rule is described as special because it doesn't follow the normal
* patterns of function calls, even for built-in functions. Since this
* does not match the standard (generic) function call syntax, this function
* was implemented as a standalone alternative in {@link #primary_expr},
* which makes it a peer of the generic {@link #func_call} rule.
* <p>
* Ambiguity warnings were generated in the {@link #parameter} and
* {@link #on_stmt} rules when this rule was added to {@link #primary_expr}.
* As far as can be found, there is no real ambiguity in practice and those
* rules have had ambiguity warnings suppressed as a result.
* <p>
* Parenthesis can be optionally used in some of these functions as noted
* in the above table.
*/
public final void record_funcs() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast record_funcs_AST = null;
Token a = null;
Aast a_AST = null;
Token b = null;
Aast b_AST = null;
Token c = null;
Aast c_AST = null;
Token d = null;
Aast d_AST = null;
Token e = null;
Aast e_AST = null;
Token i = null;
Aast i_AST = null;
Token er = null;
Aast er_AST = null;
Token re = null;
Aast re_AST = null;
Token ro = null;
Aast ro_AST = null;
Token rj = null;
Aast rj_AST = null;
Token rs = null;
Aast rs_AST = null;
Token rd = null;
Aast rd_AST = null;
Token rl = null;
Aast rl_AST = null;
try { // for error handling
boolean matched_set = false;
int ftype = -1;
String fname = LT(1).getText();
NameNode nothing = null;
{
switch ( LA(1)) {
case KW_AMBIG:
case KW_AVAIL:
case KW_CUR_CHG:
case KW_LOCKED:
case KW_NEW:
{
{
switch ( LA(1)) {
case KW_AVAIL:
{
a = LT(1);
a_AST = (Aast)astFactory.create(a);
astFactory.makeASTRoot(currentAST, a_AST);
match(KW_AVAIL);
saveAndReplaceType(a_AST, FUNC_LOGICAL);
break;
}
case KW_AMBIG:
{
b = LT(1);
b_AST = (Aast)astFactory.create(b);
astFactory.makeASTRoot(currentAST, b_AST);
match(KW_AMBIG);
saveAndReplaceType(b_AST, FUNC_LOGICAL);
break;
}
case KW_CUR_CHG:
{
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CUR_CHG);
saveAndReplaceType(c_AST, FUNC_LOGICAL);
break;
}
case KW_LOCKED:
{
d = LT(1);
d_AST = (Aast)astFactory.create(d);
astFactory.makeASTRoot(currentAST, d_AST);
match(KW_LOCKED);
saveAndReplaceType(d_AST, FUNC_LOGICAL);
break;
}
case KW_NEW:
{
e = LT(1);
e_AST = (Aast)astFactory.create(e);
astFactory.makeASTRoot(currentAST, e_AST);
match(KW_NEW);
saveAndReplaceType(e_AST, FUNC_LOGICAL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LPARENS)) {
lparens();
astFactory.addASTChild(currentAST, returnAST);
matched_set = true;
}
else if ((_tokenSet_13.member(LA(1)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
{
if (((LA(1)==RPARENS) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3))))&&( matched_set )) {
rparens();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
break;
}
case KW_INPUT:
{
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.makeASTRoot(currentAST, i_AST);
match(KW_INPUT);
saveAndReplaceType(i_AST, FUNC_POLY);
primary_expr();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_RECID:
case KW_DATA_SM:
case KW_ERROR:
case KW_REC_LEN:
case KW_REJECTED:
case KW_ROW_STAT:
case KW_ROWID:
{
{
switch ( LA(1)) {
case KW_ERROR:
{
er = LT(1);
er_AST = (Aast)astFactory.create(er);
astFactory.makeASTRoot(currentAST, er_AST);
match(KW_ERROR);
saveAndReplaceType(er_AST, FUNC_LOGICAL);
break;
}
case KW_RECID:
{
re = LT(1);
re_AST = (Aast)astFactory.create(re);
astFactory.makeASTRoot(currentAST, re_AST);
match(KW_RECID);
saveAndReplaceType(re_AST, FUNC_RECID);
break;
}
case KW_ROWID:
{
ro = LT(1);
ro_AST = (Aast)astFactory.create(ro);
astFactory.makeASTRoot(currentAST, ro_AST);
match(KW_ROWID);
saveAndReplaceType(ro_AST, FUNC_ROWID);
break;
}
case KW_REJECTED:
{
rj = LT(1);
rj_AST = (Aast)astFactory.create(rj);
astFactory.makeASTRoot(currentAST, rj_AST);
match(KW_REJECTED);
saveAndReplaceType(rj_AST, FUNC_LOGICAL);
break;
}
case KW_ROW_STAT:
{
rs = LT(1);
rs_AST = (Aast)astFactory.create(rs);
astFactory.makeASTRoot(currentAST, rs_AST);
match(KW_ROW_STAT);
saveAndReplaceType(rs_AST, FUNC_INT);
break;
}
case KW_DATA_SM:
{
rd = LT(1);
rd_AST = (Aast)astFactory.create(rd);
astFactory.makeASTRoot(currentAST, rd_AST);
match(KW_DATA_SM);
saveAndReplaceType(rd_AST, FUNC_LOGICAL);
break;
}
case KW_REC_LEN:
{
rl = LT(1);
rl_AST = (Aast)astFactory.create(rl);
astFactory.makeASTRoot(currentAST, rl_AST);
match(KW_REC_LEN);
saveAndReplaceType(rl_AST, FUNC_INT);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
lparens();
astFactory.addASTChild(currentAST, returnAST);
nothing=record(true, false, false);
astFactory.addASTChild(currentAST, returnAST);
rparens();
astFactory.addASTChild(currentAST, returnAST);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
record_funcs_AST = (Aast)currentAST.root;
// write our function-specific annotations
sym.annotateFunction(fname, record_funcs_AST, false);
record_funcs_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = record_funcs_AST;
}
/**
* Matches all Progress 4GL function calls that take parenthesized parameter
* lists. Built-in Progress functions that don't take arguments also do not
* take parenthesized parameters. These special cases are handled as
* predefined variables in the symbol dictionary, since they essentially are
* read-only variables even though they are called functions.
* <p>
* The matching portion of this rule comes in 2 parts:
* <ul>
* <li> The leftmost token is the function name. This is defined as the
* union of the set of all function token types (one for each return
* data type, e.g. <code>FUNC_INT</code>) and the set of all possible
* alternatives for symbol names (a reference to the {@link #symbol}
* for function names). Both <code>lvalue</code> and
* <code>func_call</code> refer to a leftmost token that includes the
* symbol text. This creates an ambiguity that is only resolved by
* lookahead <b>and</b> the proper ordering of the rules (since both
* are equal alternatives in the <code>primary_expr</code> rule).
* <li> The next part is the {@link #func_call_parameters}.
* </ul>
* <p>
* It is required that where this rule is referenced as one alternative that
* conflicts with the definitions of other alternatives (see
* {@link #primary_expr} and {@link #lvalue}), <b>the order of the
* alternatives must be more specific (in terms of matching criteria) to less
* specific</b>. Since the <code>func_call</code> rule contains the very
* specific <code>symbol</code> followed by <code>LPARENS</code> pattern,
* it is more specific than a simple <code>symbol</code> by itself (which is
* the definition of an <code>lvalue</code>. For this reason,
* <code>func_call</code> must always be placed ahead of <code>lvalue</code>
* in alternative lists.
* <p>
* The inclusion of the <code>malformed_symbol</code> rule ensures that all
* symbols that are followed by an <code>LPARENS</code> are considered a
* function call and will be matched by this rule. This means that the
* top level expression processing will include a symbol as one of the options
* for its leftmost token, thus "pulling" the recursive descent
* processing down the <code>expr</code> rule.
* <p>
* It is important to note that in the end, it is not really valid to have
* a token type of <code>SYMBOL</code> since this could be anything. What we
* really require is a leftmost token that is one of the valid function
* tokens:
* <pre>
* FUNC_CHAR
* FUNC_CLASS
* FUNC_COM_HANDLE
* FUNC_DATE
* FUNC_DATETIME
* FUNC_DATETIME_TZ
* FUNC_DEC
* FUNC_INT
* FUNC_INT64
* FUNC_HANDLE
* FUNC_LOGICAL
* FUNC_LONGCHAR
* FUNC_MEMPTR
* FUNC_RAW
* FUNC_RECID
* FUNC_ROWID
* FUNC_POLY
* </pre>
* The difference between a <code>SYMBOL</code> and a <code>FUNC_INT</code>
* can only be determined by context (the fact that the lookahead code has
* identified a match with a <code>SYMBOL</code> token followed by an
* <code>LPARENS</code> token which is a construct that can <b>only</b> occur
* in a function call. Thus <b>if</b> a match is found using lookahead (in
* the rule that calls this one), then it <b>must</b> be correct and
* necessary to convert the <code>SYMBOL</code> token type into the correct
* function type, using a lookup into the function namespace. This is done in
* an init action that is processed at the beginning of this rule. In this
* way, the rest of the rule only sees the first token as a valid function
* token type and never tries to call the <code>symbol</code> rule since
* calling that rule would actually try to match (and consume from the
* token stream) a <code>SYMBOL</code> token type. <b>Specifying a rule
* reference to obtain its value from a lookahead perspective but then
* changing the token's type such that the rule reference never gets called,
* is the critical trick that enables context sensitive symbol names!</b>
* <p>
* All functions have a token type associated with their respective return
* value. Some built-in functions may have the special type of
* <code>FUNC_POLY</code>. This special type indicates that the function can
* return multiple different return types. The built-in functions typically
* implement this return type based on the type of the parameters passed.
* User-defined functions cannot provide the same feature, this can only
* occur in built-in functions.
* <p>
* The exit action will save any original token type that rewriting may have
* erased. This will allow future processing to access this as an annotation
* named 'oldtype'.
* <p>
* Built-in functions have a language keyword as the function name. This
* means that built-ins can support abbreviations. It also means that some
* built-in functions cannot be hidden by a user-defined function, if the
* associated keyword is reserved. If the keyword is not reserved, then a
* built-in function is hidden in the namespace by a user-defined function
* of the same name. This method's token type rewriting is dependent upon
* this logic being implemented in the <code>SymbolResolver</code> class.
* See {@link SymbolResolver#lookupFunction}.
* <p>
* To ensure this method sees tokens matching the list of functions with
* reserved names, the {@link #reserved_functions} method is included as
* an alternative. This is the same 'pull' trick that is being used for
* generic symbols above. The reason that the generic symbol technique is
* not enough to pull reserved functions is that only unreserved keywords
* are pulled by the <code>symbol</code> method. This can't be changed
* without negative impacts on other code, since <code>symbol</code> is
* used in many locations in the parser. Instead a custom method was
* created to generate pull.
*/
public final void func_call() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast func_call_AST = null;
try { // for error handling
int oldtype = -1;
int current = LA(1);
String funcname = LT(1).getText();
boolean builtin = false;
boolean isFieldArg = false;
if (current < BEGIN_FUNCTYPES || current > END_FUNCTYPES)
{
Function func = sym.lookupFunctionDef(funcname);
int newtype = sym.lookupWrappedType(func);
// there should always be a match in valid Progress 4GL source
// so we throw an exception if this is not the case
if (newtype != -1)
{
oldtype = LA(1);
// dynamic-invoke allows INPUT parameters
builtin = func.isBuiltin() && oldtype != KW_DYN_INVK;
LT(1).setType(newtype);
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
isFieldArg = oldtype == KW_FIRST_OF ||
oldtype == KW_LAST_OF ||
oldtype == KW_FIRST ||
oldtype == KW_LAST;
if (isFieldArg)
{
preferFields = true;
}
}
{
{
switch ( LA(1)) {
case FUNC_CHAR:
{
Aast tmp1510_AST = null;
tmp1510_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1510_AST);
match(FUNC_CHAR);
break;
}
case FUNC_CLASS:
{
Aast tmp1511_AST = null;
tmp1511_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1511_AST);
match(FUNC_CLASS);
break;
}
case FUNC_COM_HANDLE:
{
Aast tmp1512_AST = null;
tmp1512_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1512_AST);
match(FUNC_COM_HANDLE);
break;
}
case FUNC_DATE:
{
Aast tmp1513_AST = null;
tmp1513_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1513_AST);
match(FUNC_DATE);
break;
}
case FUNC_DATETIME:
{
Aast tmp1514_AST = null;
tmp1514_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1514_AST);
match(FUNC_DATETIME);
break;
}
case FUNC_DATETIME_TZ:
{
Aast tmp1515_AST = null;
tmp1515_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1515_AST);
match(FUNC_DATETIME_TZ);
break;
}
case FUNC_DEC:
{
Aast tmp1516_AST = null;
tmp1516_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1516_AST);
match(FUNC_DEC);
break;
}
case FUNC_HANDLE:
{
Aast tmp1517_AST = null;
tmp1517_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1517_AST);
match(FUNC_HANDLE);
break;
}
case FUNC_INT:
{
Aast tmp1518_AST = null;
tmp1518_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1518_AST);
match(FUNC_INT);
break;
}
case FUNC_INT64:
{
Aast tmp1519_AST = null;
tmp1519_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1519_AST);
match(FUNC_INT64);
break;
}
case FUNC_LOGICAL:
{
Aast tmp1520_AST = null;
tmp1520_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1520_AST);
match(FUNC_LOGICAL);
break;
}
case FUNC_LONGCHAR:
{
Aast tmp1521_AST = null;
tmp1521_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1521_AST);
match(FUNC_LONGCHAR);
break;
}
case FUNC_MEMPTR:
{
Aast tmp1522_AST = null;
tmp1522_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1522_AST);
match(FUNC_MEMPTR);
break;
}
case FUNC_RAW:
{
Aast tmp1523_AST = null;
tmp1523_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1523_AST);
match(FUNC_RAW);
break;
}
case FUNC_RECID:
{
Aast tmp1524_AST = null;
tmp1524_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1524_AST);
match(FUNC_RECID);
break;
}
case FUNC_ROWID:
{
Aast tmp1525_AST = null;
tmp1525_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1525_AST);
match(FUNC_ROWID);
break;
}
case FUNC_POLY:
{
Aast tmp1526_AST = null;
tmp1526_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1526_AST);
match(FUNC_POLY);
break;
}
case KW_U_MSG:
case KW_ASC:
case KW_ALIAS:
case KW_CAN_DO:
case KW_CAST:
case KW_CHR:
case KW_CONN_ED:
case KW_COUNT_OF:
case KW_DBCP:
case KW_DBCOLL:
case KW_DBPARAM:
case KW_DBREST:
case KW_DBTASKID:
case KW_DBTYPE:
case KW_DBVERS:
case KW_DYN_ENUM:
case KW_DYN_FUNC:
case KW_DYN_INVK:
case KW_DYN_PROP:
case KW_ENCODE:
case KW_ENTRY:
case KW_ETIME:
case KW_FILL:
case KW_FIRST:
case KW_FIRST_OF:
case KW_FR_COL:
case KW_FR_DOWN:
case KW_FR_LINE:
case KW_FR_ROW:
case KW_GET_BYTE:
case KW_GET_CODP:
case KW_GET_COLL:
case KW_HASHCODE:
case KW_INDEX:
case KW_IS_LEAD:
case KW_KBLABEL:
case KW_KEYCODE:
case KW_KEYFUNC:
case KW_KEYLAB:
case KW_KW:
case KW_LAST:
case KW_LAST_OF:
case KW_LDBNAME:
case KW_LIB:
case KW_LINE_CNT:
case KW_LOOKUP:
case KW_MEMBER:
case KW_NUM_ENT:
case KW_PAGE_NUM:
case KW_PDBNAME:
case KW_PROGNAME:
case KW_PROVER:
case KW_QRY_OFF:
case KW_R_INDEX:
case KW_SDBNAME:
case KW_SEARCH:
case KW_SETUSER:
case KW_TO_ROWID:
case KW_TRIM:
case KW_USERID:
{
reserved_functions();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case UNKNOWN_TOKEN:
{
Aast tmp1527_AST = null;
tmp1527_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1527_AST);
match(UNKNOWN_TOKEN);
break;
}
default:
if ((_tokenSet_15.member(LA(1)))) {
symbol();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
func_call_parameters(builtin);
astFactory.addASTChild(currentAST, returnAST);
}
func_call_AST = (Aast)currentAST.root;
// save any original token type that rewriting may have erased
if (oldtype != -1)
func_call_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
// write our function-specific annotations
sym.annotateFunction(funcname, func_call_AST, false);
if (isFieldArg)
{
preferFields = false;
}
func_call_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = func_call_AST;
}
/**
* This rule implements the special built-in <code>ACCUM</code> function,
* which can be used in an expression (which is what differentiates
* it from the language statement of the same name). Note that this construct
* inherently conflicts with the language statement and the parser resolves
* this just as Progress does: by giving the language statement
* {@link #accumulate_stmt} precedence and thus matching on it first (in the
* top-level {@link #statement} rule rather than in {@link #assignment}
* which is how this current rule gets matched.
* <p>
* This rule is described as special because it doesn't follow the normal
* patterns of function calls, even for built-in functions. In particular,
* it has 2 unparenthesized parameters that are actually either a
* multi-keyword {@link #aggregate_phrase} or an {@link #expr}. Since this
* does not match the standard (generic) function call syntax, this function
* was implemented as a standalone alternative in {@link #primary_expr},
* which makes it a peer of the generic {@link #func_call} rule.
* <p>
* Ambiguity warnings were generated in the <code>aggregate_phrase</code>
* when this rule was added to the {@link #primary_expr}. As far as can be
* found, there is no real ambiguity in practice and that rule has had
* ambiguity warnings suppressed as a result.
*/
public final void accum_function() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast accum_function_AST = null;
Token a = null;
Aast a_AST = null;
try { // for error handling
a = LT(1);
a_AST = (Aast)astFactory.create(a);
astFactory.makeASTRoot(currentAST, a_AST);
match(KW_ACCUM);
saveAndReplaceType(a_AST, FUNC_POLY);
aggregate_phrase();
astFactory.addASTChild(currentAST, returnAST);
expr();
astFactory.addASTChild(currentAST, returnAST);
accum_function_AST = (Aast)currentAST.root;
// write our function-specific annotations
sym.annotateFunction(accum_function_AST.getText(), accum_function_AST, false);
accum_function_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = accum_function_AST;
}
/**
* This rule implements the special built-in <code>CAN-FIND</code> function,
* which can be used in an expression.
* <p>
* This rule is described as special because it doesn't follow the normal
* patterns of function calls, even for built-in functions. In particular,
* its parameters are an exact match for the {@link #find_stmt} excluding
* the <code>FIND</code> keyword itself! Since this does not match the
* standard (generic) function call syntax, this function was implemented
* as a standalone alternative in {@link #primary_expr}, which makes it a
* peer of the generic {@link #func_call} rule.
*/
public final void can_find_function() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast can_find_function_AST = null;
Token c = null;
Aast c_AST = null;
try { // for error handling
// push a scope, where the target buffers will be added
sym.addSchemaScope(false);
c = LT(1);
c_AST = (Aast)astFactory.create(c);
astFactory.makeASTRoot(currentAST, c_AST);
match(KW_CAN_FIND);
saveAndReplaceType(c_AST, FUNC_LOGICAL);
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_FIRST:
{
Aast tmp1528_AST = null;
tmp1528_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1528_AST);
match(KW_FIRST);
break;
}
case KW_LAST:
{
Aast tmp1529_AST = null;
tmp1529_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1529_AST);
match(KW_LAST);
break;
}
case KW_NEXT:
{
Aast tmp1530_AST = null;
tmp1530_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1530_AST);
match(KW_NEXT);
break;
}
case KW_CURRENT:
{
Aast tmp1531_AST = null;
tmp1531_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1531_AST);
match(KW_CURRENT);
break;
}
default:
if ((LA(1)==KW_PREV) && (_tokenSet_13.member(LA(2))) && (_tokenSet_256.member(LA(3)))) {
Aast tmp1532_AST = null;
tmp1532_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1532_AST);
match(KW_PREV);
}
else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_256.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
boolean oldUniqueFieldMatch = sym.setUniqueFieldMatch(false);
record_phrase(true, false);
astFactory.addASTChild(currentAST, returnAST);
sym.setUniqueFieldMatch(oldUniqueFieldMatch);
rparens();
astFactory.addASTChild(currentAST, returnAST);
can_find_function_AST = (Aast)currentAST.root;
// write our function-specific annotations
sym.annotateFunction(can_find_function_AST.getText(), can_find_function_AST, false);
// remove the scope, but do not propagate
sym.deleteSchemaScope(false);
can_find_function_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = can_find_function_AST;
}
/**
* This rule implements the special built-in <code>SUPER</code> function,
* which can be used in an expression.
* <p>
* This rule is described as special because it doesn't follow the normal
* patterns of function calls, even for built-in functions. In particular,
* its optional parameters are an exact match for the {@link #parameter}
* rule. Since this does not match the standard (generic) function call
* syntax, this function was implemented as a standalone alternative in
* {@link #primary_expr}, which makes it a peer of the generic
* {@link #func_call} rule.
* <p>
* ANTLR's bogus ambiguity warnings have been disabled.
*/
public final void super_function() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast super_function_AST = null;
Token s = null;
Aast s_AST = null;
try { // for error handling
s = LT(1);
s_AST = (Aast)astFactory.create(s);
astFactory.makeASTRoot(currentAST, s_AST);
match(KW_SUPER);
saveAndReplaceType(s_AST, FUNC_POLY);
{
if ((LA(1)==LPARENS) && (_tokenSet_79.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
param_passing_list(false);
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
super_function_AST = (Aast)currentAST.root;
// write our function-specific annotations
sym.annotateFunction(super_function_AST.getText(), super_function_AST, false);
super_function_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = super_function_AST;
}
/**
* This rule implements the special built-in functions that can be used
* used in an expression but which don't take normal parenthesized parameters
* AND for which the single {@link #lvalue} parameter for each of these is
* prefixed in front of the function name. Note that the <code>lvalue</code>
* is not matched here, but rather in {@link #primary_expr}.
* <p>
* The following are matched:
* <p>
* <pre>
* lvalue ENTERED
* lvalue NOT ENTERED
* </pre>
* <p>
* This rule is described as special because it doesn't follow the normal
* patterns of function calls, even for built-in functions. Since this
* does not match the standard (generic) function call syntax, this function
* was implemented as an option after the <code>lvalue</code> alternative in
* in the calling rule.
*/
public final void postfix_funcs() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast postfix_funcs_AST = null;
try { // for error handling
boolean entered = true;
{
switch ( LA(1)) {
case KW_NOT:
{
Aast tmp1533_AST = null;
tmp1533_AST = (Aast)astFactory.create(LT(1));
match(KW_NOT);
entered = false;
break;
}
case KW_ENTERED:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
Aast tmp1534_AST = null;
tmp1534_AST = (Aast)astFactory.create(LT(1));
match(KW_ENTERED);
postfix_funcs_AST = (Aast)currentAST.root;
String funcName = "entered";
int oldtype = KW_ENTERED;
if (!entered)
{
funcName = "not entered";
oldtype = NOT_ENTERED;
}
postfix_funcs_AST = (Aast)astFactory.make( (new ASTArray(1)).add((Aast)astFactory.create(FUNC_LOGICAL,funcName)));
// write our function-specific annotations
sym.annotateFunction(funcName, postfix_funcs_AST, false);
// add the oldtype annotation
postfix_funcs_AST.putAnnotation("oldtype", Long.valueOf(oldtype));
currentAST.root = postfix_funcs_AST;
currentAST.child = postfix_funcs_AST!=null &&postfix_funcs_AST.getFirstChild()!=null ?
postfix_funcs_AST.getFirstChild() : postfix_funcs_AST;
currentAST.advanceChildToEnd();
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = postfix_funcs_AST;
}
/**
* This rule implements the special built-in <code>IF THEN ELSE</code>
* function, which can be used in an expression (which is what differentiates
* it from the language statement of the same name). Note that this construct
* inherently conflicts with the language statement and the parser resolves
* this just as Progress does: by giving the language statement
* {@link #if_stmt} precedence and thus matching on it first (in the
* top-level {@link #statement} rule rather than in {@link #assignment}
* which is how this current rule gets matched.
* <p>
* This rule is described as special because it doesn't follow the normal
* patterns of function calls, even for built-in functions. In particular,
* it has 3 reserved keywords that are all requried (the <code>ELSE</code>
* is not optional) and in between each keyword is an expression. Since this
* does not match the standard (generic) function call syntax, this function
* was implemented as a standalone alternative in {@link #primary_expr},
* which makes it a peer of the generic {@link #func_call} rule.
* <p>
* Ambiguity warnings were generated in the {@link #log_and_expr} and in
* {@link #sum_expr} when this rule was added to the {@link #primary_expr}
* rule. As far as can be found, there is no real ambiguity in practice and
* those rules have had ambiguity warnings suppressed as a result.
*/
public final void if_func() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast if_func_AST = null;
Token i = null;
Aast i_AST = null;
Token th = null;
Aast th_AST = null;
Token el = null;
Aast el_AST = null;
try { // for error handling
i = LT(1);
i_AST = (Aast)astFactory.create(i);
astFactory.makeASTRoot(currentAST, i_AST);
match(KW_IF);
saveAndReplaceType(i_AST, FUNC_POLY);
expr();
astFactory.addASTChild(currentAST, returnAST);
th = LT(1);
th_AST = (Aast)astFactory.create(th);
match(KW_THEN);
hide(th);
expr();
astFactory.addASTChild(currentAST, returnAST);
el = LT(1);
el_AST = (Aast)astFactory.create(el);
match(KW_ELSE);
hide(el);
expr();
astFactory.addASTChild(currentAST, returnAST);
if_func_AST = (Aast)currentAST.root;
// write our function-specific annotations
sym.annotateFunction(if_func_AST.getText(), if_func_AST, false);
if_func_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = if_func_AST;
}
/**
* Matches Progress 4GL built-in function names that are <b>reserved</b>
* keywords. This only includes functions that take parameters. Built-in
* functions that take no parameters are treated like variables. See
* {@link #reserved_variables}.
* <p>
* This is generally only used to generate the proper lookahead predictions
* in the top level parser methods, such that calling rules would see tokens
* of this type. It is expected that the calling method would rewrite the
* token type of such tokens such that this alternative is never actually
* entered at runtime. Thus this method really just provides a 'pull' into
* the calling method. See {@link #func_call}.
* <p>
* Note that there are some built-in functions that can act like variables
* OR as a normal parenthesized function. In other words, for the following
* list, the parenthesis are optional:
* <p>
* <ul>
* <li>ETIME
* <li>FRAME-COL
* <li>FRAME-DOWN
* <li>FRAME-LINE
* <li>FRAME-ROW
* <li>LINE-COUNTER
* <li>PAGE-NUMBER
* <li>PROVERSION
* <li>USERID
* </ul>
* <p>
* Such keywords are included in both this rule and in
* <code>reserved_variables</code>.
*/
public final void reserved_functions() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast reserved_functions_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_U_MSG:
{
Aast tmp1535_AST = null;
tmp1535_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1535_AST);
match(KW_U_MSG);
break;
}
case KW_ALIAS:
{
Aast tmp1536_AST = null;
tmp1536_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1536_AST);
match(KW_ALIAS);
break;
}
case KW_ASC:
{
Aast tmp1537_AST = null;
tmp1537_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1537_AST);
match(KW_ASC);
break;
}
case KW_CAN_DO:
{
Aast tmp1538_AST = null;
tmp1538_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1538_AST);
match(KW_CAN_DO);
break;
}
case KW_CAST:
{
Aast tmp1539_AST = null;
tmp1539_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1539_AST);
match(KW_CAST);
break;
}
case KW_CHR:
{
Aast tmp1540_AST = null;
tmp1540_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1540_AST);
match(KW_CHR);
break;
}
case KW_COUNT_OF:
{
Aast tmp1541_AST = null;
tmp1541_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1541_AST);
match(KW_COUNT_OF);
break;
}
case KW_CONN_ED:
{
Aast tmp1542_AST = null;
tmp1542_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1542_AST);
match(KW_CONN_ED);
break;
}
case KW_DBCP:
{
Aast tmp1543_AST = null;
tmp1543_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1543_AST);
match(KW_DBCP);
break;
}
case KW_DBCOLL:
{
Aast tmp1544_AST = null;
tmp1544_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1544_AST);
match(KW_DBCOLL);
break;
}
case KW_DBPARAM:
{
Aast tmp1545_AST = null;
tmp1545_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1545_AST);
match(KW_DBPARAM);
break;
}
case KW_DBREST:
{
Aast tmp1546_AST = null;
tmp1546_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1546_AST);
match(KW_DBREST);
break;
}
case KW_DBTASKID:
{
Aast tmp1547_AST = null;
tmp1547_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1547_AST);
match(KW_DBTASKID);
break;
}
case KW_DBTYPE:
{
Aast tmp1548_AST = null;
tmp1548_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1548_AST);
match(KW_DBTYPE);
break;
}
case KW_DBVERS:
{
Aast tmp1549_AST = null;
tmp1549_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1549_AST);
match(KW_DBVERS);
break;
}
case KW_DYN_ENUM:
{
Aast tmp1550_AST = null;
tmp1550_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1550_AST);
match(KW_DYN_ENUM);
break;
}
case KW_DYN_FUNC:
{
Aast tmp1551_AST = null;
tmp1551_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1551_AST);
match(KW_DYN_FUNC);
break;
}
case KW_DYN_INVK:
{
Aast tmp1552_AST = null;
tmp1552_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1552_AST);
match(KW_DYN_INVK);
break;
}
case KW_DYN_PROP:
{
Aast tmp1553_AST = null;
tmp1553_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1553_AST);
match(KW_DYN_PROP);
break;
}
case KW_ENCODE:
{
Aast tmp1554_AST = null;
tmp1554_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1554_AST);
match(KW_ENCODE);
break;
}
case KW_ENTRY:
{
Aast tmp1555_AST = null;
tmp1555_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1555_AST);
match(KW_ENTRY);
break;
}
case KW_ETIME:
{
Aast tmp1556_AST = null;
tmp1556_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1556_AST);
match(KW_ETIME);
break;
}
case KW_FILL:
{
Aast tmp1557_AST = null;
tmp1557_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1557_AST);
match(KW_FILL);
break;
}
case KW_FIRST:
{
Aast tmp1558_AST = null;
tmp1558_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1558_AST);
match(KW_FIRST);
break;
}
case KW_FIRST_OF:
{
Aast tmp1559_AST = null;
tmp1559_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1559_AST);
match(KW_FIRST_OF);
break;
}
case KW_FR_COL:
{
Aast tmp1560_AST = null;
tmp1560_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1560_AST);
match(KW_FR_COL);
break;
}
case KW_FR_DOWN:
{
Aast tmp1561_AST = null;
tmp1561_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1561_AST);
match(KW_FR_DOWN);
break;
}
case KW_FR_LINE:
{
Aast tmp1562_AST = null;
tmp1562_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1562_AST);
match(KW_FR_LINE);
break;
}
case KW_FR_ROW:
{
Aast tmp1563_AST = null;
tmp1563_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1563_AST);
match(KW_FR_ROW);
break;
}
case KW_GET_BYTE:
{
Aast tmp1564_AST = null;
tmp1564_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1564_AST);
match(KW_GET_BYTE);
break;
}
case KW_GET_CODP:
{
Aast tmp1565_AST = null;
tmp1565_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1565_AST);
match(KW_GET_CODP);
break;
}
case KW_GET_COLL:
{
Aast tmp1566_AST = null;
tmp1566_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1566_AST);
match(KW_GET_COLL);
break;
}
case KW_HASHCODE:
{
Aast tmp1567_AST = null;
tmp1567_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1567_AST);
match(KW_HASHCODE);
break;
}
case KW_INDEX:
{
Aast tmp1568_AST = null;
tmp1568_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1568_AST);
match(KW_INDEX);
break;
}
case KW_IS_LEAD:
{
Aast tmp1569_AST = null;
tmp1569_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1569_AST);
match(KW_IS_LEAD);
break;
}
case KW_KBLABEL:
{
Aast tmp1570_AST = null;
tmp1570_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1570_AST);
match(KW_KBLABEL);
break;
}
case KW_KEYCODE:
{
Aast tmp1571_AST = null;
tmp1571_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1571_AST);
match(KW_KEYCODE);
break;
}
case KW_KEYFUNC:
{
Aast tmp1572_AST = null;
tmp1572_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1572_AST);
match(KW_KEYFUNC);
break;
}
case KW_KEYLAB:
{
Aast tmp1573_AST = null;
tmp1573_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1573_AST);
match(KW_KEYLAB);
break;
}
case KW_KW:
{
Aast tmp1574_AST = null;
tmp1574_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1574_AST);
match(KW_KW);
break;
}
case KW_LAST:
{
Aast tmp1575_AST = null;
tmp1575_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1575_AST);
match(KW_LAST);
break;
}
case KW_LAST_OF:
{
Aast tmp1576_AST = null;
tmp1576_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1576_AST);
match(KW_LAST_OF);
break;
}
case KW_LDBNAME:
{
Aast tmp1577_AST = null;
tmp1577_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1577_AST);
match(KW_LDBNAME);
break;
}
case KW_LIB:
{
Aast tmp1578_AST = null;
tmp1578_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1578_AST);
match(KW_LIB);
break;
}
case KW_LINE_CNT:
{
Aast tmp1579_AST = null;
tmp1579_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1579_AST);
match(KW_LINE_CNT);
break;
}
case KW_LOOKUP:
{
Aast tmp1580_AST = null;
tmp1580_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1580_AST);
match(KW_LOOKUP);
break;
}
case KW_MEMBER:
{
Aast tmp1581_AST = null;
tmp1581_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1581_AST);
match(KW_MEMBER);
break;
}
case KW_NUM_ENT:
{
Aast tmp1582_AST = null;
tmp1582_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1582_AST);
match(KW_NUM_ENT);
break;
}
case KW_PAGE_NUM:
{
Aast tmp1583_AST = null;
tmp1583_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1583_AST);
match(KW_PAGE_NUM);
break;
}
case KW_PDBNAME:
{
Aast tmp1584_AST = null;
tmp1584_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1584_AST);
match(KW_PDBNAME);
break;
}
case KW_PROGNAME:
{
Aast tmp1585_AST = null;
tmp1585_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1585_AST);
match(KW_PROGNAME);
break;
}
case KW_PROVER:
{
Aast tmp1586_AST = null;
tmp1586_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1586_AST);
match(KW_PROVER);
break;
}
case KW_QRY_OFF:
{
Aast tmp1587_AST = null;
tmp1587_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1587_AST);
match(KW_QRY_OFF);
break;
}
case KW_R_INDEX:
{
Aast tmp1588_AST = null;
tmp1588_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1588_AST);
match(KW_R_INDEX);
break;
}
case KW_SDBNAME:
{
Aast tmp1589_AST = null;
tmp1589_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1589_AST);
match(KW_SDBNAME);
break;
}
case KW_SEARCH:
{
Aast tmp1590_AST = null;
tmp1590_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1590_AST);
match(KW_SEARCH);
break;
}
case KW_SETUSER:
{
Aast tmp1591_AST = null;
tmp1591_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1591_AST);
match(KW_SETUSER);
break;
}
case KW_TO_ROWID:
{
Aast tmp1592_AST = null;
tmp1592_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1592_AST);
match(KW_TO_ROWID);
break;
}
case KW_TRIM:
{
Aast tmp1593_AST = null;
tmp1593_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1593_AST);
match(KW_TRIM);
break;
}
case KW_USERID:
{
Aast tmp1594_AST = null;
tmp1594_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1594_AST);
match(KW_USERID);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
reserved_functions_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_257);
}
returnAST = reserved_functions_AST;
}
/**
* Matches a parenthesized, comma-delimited list of {@link #func_call_parm}
* parameters.
* <p>
* This matches a set of 2 or more tokens where the first is always
* <code>LPARENS</code> and the last is always <code>RPARENS</code>. In between is an
* optional expression, optionally followed by any number of
* [<code>COMMA</code> func_call_parm] constructs. This is a parameter list
* and it can contain any kind of expression. This rule calls the top level
* expression entry point allows the full variety of all possible expressions
* to be specified as parameters.
* <p>
* Note that in the resulting AST, the parenthesis and commas used to define
* the parameter list are discarded. In other words, they do not appear in
* the AST as nodes. Instead, each parameter (which can be a complete
* expression subtree or a simple single node like an lvalue) is created
* as a separate child node of the function type token. All parameters are
* maintained as child nodes in the exact order of the function call itself,
* so this is essentially the signature of the function. It it also the
* proper AST definition to enable simple evaluation of functions with any
* arbitrary signature.
* <p>
* There is an undocumented feature of the 4GL where <code>INPUT</code>,
* <code>OUTPUT</code> and <code>INPUT-OUTPUT</code> are all ignored if
* present in a function call parameter. This can be seen in the
* {@link #func_call_parm}.
*
* @param builtin
* <code>true</code> if this is a built-in function.
*/
public final void func_call_parameters(
boolean builtin
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast func_call_parameters_AST = null;
try { // for error handling
lparens();
astFactory.addASTChild(currentAST, returnAST);
{
if ((_tokenSet_24.member(LA(1)))) {
func_call_parm(builtin);
astFactory.addASTChild(currentAST, returnAST);
{
_loop1705:
do {
if ((LA(1)==COMMA)) {
comma();
astFactory.addASTChild(currentAST, returnAST);
func_call_parm(builtin);
astFactory.addASTChild(currentAST, returnAST);
}
else {
break _loop1705;
}
} while (true);
}
}
else if ((LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rparens();
astFactory.addASTChild(currentAST, returnAST);
func_call_parameters_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = func_call_parameters_AST;
}
/**
* Represents a function call parameter which is the equivalent of an
* {@link #expr} BUT it can be optionally prefaced with any of the keywords
* <code>INPUT, INPUT-OUTPUT or OUTPUT</code>. These are ignored but seem
* to be tolerated since it looks the same as <code>RUN</code> statement
* or <code>PUBLISH</code> statement parameters (as well as the various
* procedure and function declarations). The only exception to this is
* if the function call is to a built-in function that has not been overridden
* by a user-defined function. In such a case, the <code>INPUT</code> keyword
* will be treated as the built-in <code>INPUT</code> function instead of
* being ignored.
* <p>
* To actually use the <code>INPUT</code> built-in function as a parameter,
* (in a call to a user-defined function) one must parenthesize the call OR add the
* following FRAME frame-name qualifier between the KW_INPUT and the widget name.
* This is how it works in Progress! Otherwise the presence of the KW_INPUT is
* treated as an ignored mode qualifier.
*
* @param builtin
* <code>true</code> if this is a parameter to a builtin function.
*/
public final void func_call_parm(
boolean builtin
) throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast func_call_parm_AST = null;
Aast e_AST = null;
boolean isInputFunc = (LA(1) == KW_INPUT &&
LA(2) == KW_FRAME &&
resolveLvalueCoreType(4, false) != -1);
boolean classLookup = sym.isClassLookup();
sym.setClassLookup(false);
try { // for error handling
{
if (((LA(1)==KW_INPUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( !builtin && !isInputFunc )) {
Aast tmp1595_AST = null;
tmp1595_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1595_AST);
match(KW_INPUT);
}
else if ((LA(1)==KW_OUTPUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1596_AST = null;
tmp1596_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1596_AST);
match(KW_OUTPUT);
}
else if ((LA(1)==KW_IN_OUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1597_AST = null;
tmp1597_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1597_AST);
match(KW_IN_OUT);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
e_AST = (Aast)returnAST;
astFactory.addASTChild(currentAST, returnAST);
{
_loop1709:
do {
switch ( LA(1)) {
case KW_APPEND:
{
Aast tmp1598_AST = null;
tmp1598_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1598_AST);
match(KW_APPEND);
break;
}
case KW_BY_VALUE:
{
Aast tmp1599_AST = null;
tmp1599_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1599_AST);
match(KW_BY_VALUE);
break;
}
case KW_BY_REF:
{
Aast tmp1600_AST = null;
tmp1600_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1600_AST);
match(KW_BY_REF);
break;
}
case KW_BIND:
{
Aast tmp1601_AST = null;
tmp1601_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1601_AST);
match(KW_BIND);
break;
}
default:
{
break _loop1709;
}
}
} while (true);
}
sym.setClassLookup(classLookup);
func_call_parm_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_258);
}
returnAST = func_call_parm_AST;
}
/**
* Matches the array subscripting operator [ ] in all of its forms. The most
* basic version requires a single integer expression (which can be as simple
* as an integer constant or it can include a full expression including other
* variables or fields). Since Progress 4GL allows whitespace to be placed
* between the symbol name and the left bracket, as well as used arbitrarily
* inside the brackets, this subscripting support is best implemented in
* the parser. Note that the Progress documentation states that the subscript
* must be specified only as integer constants, experience proves that
* the real requirement is for it to be an integer expression.
* <p>
* In Progress it is possible to reference a range of array elements in
* some cases (e.g. the <code>DISPLAY</code> language statement) however it
* is not possible to do this in traditional expressions (i.e. Progress does
* not have integrated support for vector operations). To use this range
* subscript, the initial expression is followed by the <code>FOR</code>
* keyword and then an integer constant to specify the length of the range.
* This rule handles both forms, although there is no checking to confirm
* that the range form is only used in valid locations.
* <p>
* The resulting tree is rooted under the left bracket token and the right
* bracket is discarded.
* <p>
* When called during the processing of {@link #like_clause}, the expression
* being matched is always converted into the equivalent of a
* <code>NUM_LITERAL</code> with a value of 1. Strangely, this is how
* Progress does it. The bizarre thing here is that complete garbage can
* be inserted in this expression and if it is close enough to something that
* would be a valid expression it will be allowed. Here is a list of
* subscripts that can work:
* <p>
* <pre>
* def var array as int extent 10 init [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
*
* def var scalar1 like array[3].
* def var scalar2 like array[1].
* def var scalar3 like array[0]. -> normally invalid since 0 is out of bounds!
* def var scalar4 like array[17]. -> normally invalid since 17 is out of bounds!
* def var scalar5 like array[trash]. -> normally invalid since trash is not a var!
* def var scalar6 like array[trash + junk]. -> normally invalid since trash and junk are not vars!
* def var scalar7 like array[1 + 2].
* </pre>
* <p>
* Additionally, with the advent of .NET object support in 10.2x, the index
* property concept of .NET is supported. This means that any kind of
* expression (not just numeric) can be used to index into .NET object arrays
* if that .NET class has the proper support.
* <p>
* In Progress, all of the above are treated as a <code>like array[1]</code>
* though this is undocumented and non-intuitive. Either way, we do the
* same thing.
* <p>
* This rule is only called by the {@link #lvalue} rule.
*/
public final void subscript() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast subscript_AST = null;
Token rb = null;
Aast rb_AST = null;
try { // for error handling
boolean oldpref = preferWidgets;
// temporarily disable widget preference so the expression will
// parse without widget refs
if (oldpref)
{
preferWidgets = false;
}
{
Aast tmp1602_AST = null;
tmp1602_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1602_AST);
match(LBRACKET);
{
if (((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( !inLikeClause )) {
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_FOR:
{
Aast tmp1603_AST = null;
tmp1603_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1603_AST);
match(KW_FOR);
whole_number_literal();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case RBRACKET:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if (((LA(1) >= DOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
likeSubscript();
astFactory.addASTChild(currentAST, returnAST);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
rb = LT(1);
rb_AST = (Aast)astFactory.create(rb);
match(RBRACKET);
hide(rb);
}
// reset back to state at entrance to this method
if (oldpref)
{
preferWidgets = true;
}
subscript_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = subscript_AST;
}
/**
* Matches a single COM parameter which is an {@link #expr} and which may
* have optional modifiers for overriding data types (see
* {@link #com_as_clause}) or for specifying passing parameters by pointer
* (<code>BY-POINTER</code> or <code>BY-VARIANT-POINTER</code>).
* <p>
* The tree will always be rooted by <code>COM_PARAMETER</code>. Even if
* there is no parameter expression, this rule will return a single node
* of this type so that the null parameter construct of COM can be properly
* supported. In other words, the expression is optional.
* <p>
* <code>KW_IN_OUT</code> and <code>KW_OUTPUT</code> are matched as
* optionally prefacing this construct.
* <p>
* Called by {@link #com_property_or_method}.
*/
public final void com_parameter() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast com_parameter_AST = null;
try { // for error handling
astFactory.makeASTRoot(currentAST, (Aast)astFactory.create(COM_PARAMETER,""));
boolean isInputFunc = (LA(1) == KW_INPUT &&
LA(2) == KW_FRAME &&
resolveLvalueCoreType(4, false) != -1);
{
if ((_tokenSet_24.member(LA(1)))) {
{
if (((LA(1)==KW_INPUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK)))&&( !isInputFunc )) {
Aast tmp1604_AST = null;
tmp1604_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1604_AST);
match(KW_INPUT);
}
else if ((LA(1)==KW_IN_OUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1605_AST = null;
tmp1605_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1605_AST);
match(KW_IN_OUT);
}
else if ((LA(1)==KW_OUTPUT) && (_tokenSet_24.member(LA(2))) && ((LA(3) >= DOT && LA(3) <= JUNK))) {
Aast tmp1606_AST = null;
tmp1606_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1606_AST);
match(KW_OUTPUT);
}
else if ((_tokenSet_24.member(LA(1))) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
expr();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case KW_AS:
{
com_as_clause();
astFactory.addASTChild(currentAST, returnAST);
break;
}
case KW_BY_PTR:
case KW_BY_VAR_P:
case COMMA:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case KW_BY_PTR:
{
Aast tmp1607_AST = null;
tmp1607_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1607_AST);
match(KW_BY_PTR);
break;
}
case KW_BY_VAR_P:
{
Aast tmp1608_AST = null;
tmp1608_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1608_AST);
match(KW_BY_VAR_P);
break;
}
case COMMA:
case RPARENS:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((LA(1)==COMMA||LA(1)==RPARENS)) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
com_parameter_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_29);
}
returnAST = com_parameter_AST;
}
/**
* Matches the construct following a COM parameter which overrides the
* default Progress type conversion with a more specific COM type conversion.
* The first token must be a <code>KW_AS</code> and this will root the
* sub-tree.
* <p>
* The following types are known to be possible (and the normal ones in
* {@link #as_clause} are known to be impossible to use here):
* <p>
* <pre>
* CURRENCY
* FLOAT
* ERROR-CODE
* IUNKNOWN
* SHORT
* UNSIGNED-BYTE
* </pre>
* <p>
* Called by {@link #com_parameter}.
*/
public final void com_as_clause() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast com_as_clause_AST = null;
try { // for error handling
Aast tmp1609_AST = null;
tmp1609_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1609_AST);
match(KW_AS);
{
switch ( LA(1)) {
case KW_CURRENCY:
{
Aast tmp1610_AST = null;
tmp1610_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1610_AST);
match(KW_CURRENCY);
break;
}
case KW_FLOAT:
{
Aast tmp1611_AST = null;
tmp1611_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1611_AST);
match(KW_FLOAT);
break;
}
case KW_ERR_CODE:
{
Aast tmp1612_AST = null;
tmp1612_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1612_AST);
match(KW_ERR_CODE);
break;
}
case KW_IUNKNOWN:
{
Aast tmp1613_AST = null;
tmp1613_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1613_AST);
match(KW_IUNKNOWN);
break;
}
case KW_SHORT:
{
Aast tmp1614_AST = null;
tmp1614_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1614_AST);
match(KW_SHORT);
break;
}
case KW_UNS_BYTE:
{
Aast tmp1615_AST = null;
tmp1615_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1615_AST);
match(KW_UNS_BYTE);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
com_as_clause_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_259);
}
returnAST = com_as_clause_AST;
}
/**
* Matches Progress 4GL built-in variable names that are <b>reserved</b>
* keywords. This includes functions that take NO parameters. Built-in
* functions that take no parameters are treated like variables. For more
* on functions that take parameters and which have reserved names, see
* {@link #reserved_functions}.
* <p>
* This rule also lists those system handles that are reserved keywords,
* since such handles are essentially global variables and thus are
* implemented here as such.
* <p>
* This is generally only used to generate the proper lookahead predictions
* in the top level parser methods, such that calling rules would see tokens
* of this type. It is expected that the calling method would rewrite the
* token type of such tokens such that this alternative is never actually
* entered at runtime. Thus this method really just provides a 'pull' into
* the calling method. See {@link #lvalue}.
* <p>
* Note that there are some built-in functions that can act like variables
* OR as a normal parenthesized function. In other words, for the following
* list, the parenthesis are optional:
* <p>
* <ul>
* <li>ETIME
* <li>GET-CODEPAGE
* <li>GET-CODEPAGES
* <li>FRAME-COL
* <li>FRAME-DOWN
* <li>FRAME-LINE
* <li>FRAME-ROW
* <li>LINE-COUNTER
* <li>PAGE-NUMBER
* <li>PROVERSION
* <li>USERID
* </ul>
* <p>
* Such keywords are included in both this rule and in
* <code>reserved_functions</code>.
*/
public final void reserved_variables() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast reserved_variables_AST = null;
try { // for error handling
{
switch ( LA(1)) {
case KW_U_CTRL:
{
Aast tmp1616_AST = null;
tmp1616_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1616_AST);
match(KW_U_CTRL);
break;
}
case KW_U_MSG:
{
Aast tmp1617_AST = null;
tmp1617_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1617_AST);
match(KW_U_MSG);
break;
}
case KW_U_SERIAL:
{
Aast tmp1618_AST = null;
tmp1618_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1618_AST);
match(KW_U_SERIAL);
break;
}
case KW_U_PCTRL:
{
Aast tmp1619_AST = null;
tmp1619_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1619_AST);
match(KW_U_PCTRL);
break;
}
case KW_ACT_FORM:
{
Aast tmp1620_AST = null;
tmp1620_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1620_AST);
match(KW_ACT_FORM);
break;
}
case KW_ACT_WIN:
{
Aast tmp1621_AST = null;
tmp1621_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1621_AST);
match(KW_ACT_WIN);
break;
}
case KW_AUD_CTRL:
{
Aast tmp1622_AST = null;
tmp1622_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1622_AST);
match(KW_AUD_CTRL);
break;
}
case KW_AUD_POL:
{
Aast tmp1623_AST = null;
tmp1623_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1623_AST);
match(KW_AUD_POL);
break;
}
case KW_CLIP:
{
Aast tmp1624_AST = null;
tmp1624_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1624_AST);
match(KW_CLIP);
break;
}
case KW_CODEBASE:
{
Aast tmp1625_AST = null;
tmp1625_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1625_AST);
match(KW_CODEBASE);
break;
}
case KW_COMPILER:
{
Aast tmp1626_AST = null;
tmp1626_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1626_AST);
match(KW_COMPILER);
break;
}
case KW_CUR_LANG:
{
Aast tmp1627_AST = null;
tmp1627_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1627_AST);
match(KW_CUR_LANG);
break;
}
case KW_CUR_WIN:
{
Aast tmp1628_AST = null;
tmp1628_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1628_AST);
match(KW_CUR_WIN);
break;
}
case KW_DATASRV:
{
Aast tmp1629_AST = null;
tmp1629_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1629_AST);
match(KW_DATASRV);
break;
}
case KW_DBNAME:
{
Aast tmp1630_AST = null;
tmp1630_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1630_AST);
match(KW_DBNAME);
break;
}
case KW_DEBUGGER:
{
Aast tmp1631_AST = null;
tmp1631_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1631_AST);
match(KW_DEBUGGER);
break;
}
case KW_DEF_WIN:
{
Aast tmp1632_AST = null;
tmp1632_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1632_AST);
match(KW_DEF_WIN);
break;
}
case KW_DSL_MGR:
{
Aast tmp1633_AST = null;
tmp1633_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1633_AST);
match(KW_DSL_MGR);
break;
}
case KW_ERR_STAT:
{
Aast tmp1634_AST = null;
tmp1634_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1634_AST);
match(KW_ERR_STAT);
break;
}
case KW_ETIME:
{
Aast tmp1635_AST = null;
tmp1635_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1635_AST);
match(KW_ETIME);
break;
}
case KW_FIL_INFO:
{
Aast tmp1636_AST = null;
tmp1636_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1636_AST);
match(KW_FIL_INFO);
break;
}
case KW_FOCUS:
{
Aast tmp1637_AST = null;
tmp1637_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1637_AST);
match(KW_FOCUS);
break;
}
case KW_FR_COL:
{
Aast tmp1638_AST = null;
tmp1638_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1638_AST);
match(KW_FR_COL);
break;
}
case KW_FR_DB:
{
Aast tmp1639_AST = null;
tmp1639_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1639_AST);
match(KW_FR_DB);
break;
}
case KW_FR_DOWN:
{
Aast tmp1640_AST = null;
tmp1640_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1640_AST);
match(KW_FR_DOWN);
break;
}
case KW_FR_FIELD:
{
Aast tmp1641_AST = null;
tmp1641_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1641_AST);
match(KW_FR_FIELD);
break;
}
case KW_FR_FILE:
{
Aast tmp1642_AST = null;
tmp1642_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1642_AST);
match(KW_FR_FILE);
break;
}
case KW_FR_INDEX:
{
Aast tmp1643_AST = null;
tmp1643_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1643_AST);
match(KW_FR_INDEX);
break;
}
case KW_FR_LINE:
{
Aast tmp1644_AST = null;
tmp1644_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1644_AST);
match(KW_FR_LINE);
break;
}
case KW_FR_NAME:
{
Aast tmp1645_AST = null;
tmp1645_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1645_AST);
match(KW_FR_NAME);
break;
}
case KW_FR_ROW:
{
Aast tmp1646_AST = null;
tmp1646_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1646_AST);
match(KW_FR_ROW);
break;
}
case KW_FR_VAL:
{
Aast tmp1647_AST = null;
tmp1647_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1647_AST);
match(KW_FR_VAL);
break;
}
case KW_FWD_DRIV:
{
Aast tmp1648_AST = null;
tmp1648_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1648_AST);
match(KW_FWD_DRIV);
break;
}
case KW_GW:
{
Aast tmp1649_AST = null;
tmp1649_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1649_AST);
match(KW_GW);
break;
}
case KW_GET_CODP:
{
Aast tmp1650_AST = null;
tmp1650_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1650_AST);
match(KW_GET_CODP);
break;
}
case KW_GO_PEND:
{
Aast tmp1651_AST = null;
tmp1651_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1651_AST);
match(KW_GO_PEND);
break;
}
case KW_IS_ATTR:
{
Aast tmp1652_AST = null;
tmp1652_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1652_AST);
match(KW_IS_ATTR);
break;
}
case KW_LASTKEY:
{
Aast tmp1653_AST = null;
tmp1653_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1653_AST);
match(KW_LASTKEY);
break;
}
case KW_LAST_EVT:
{
Aast tmp1654_AST = null;
tmp1654_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1654_AST);
match(KW_LAST_EVT);
break;
}
case KW_LINE_CNT:
{
Aast tmp1655_AST = null;
tmp1655_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1655_AST);
match(KW_LINE_CNT);
break;
}
case KW_LOG_MGR:
{
Aast tmp1656_AST = null;
tmp1656_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1656_AST);
match(KW_LOG_MGR);
break;
}
case KW_MSG_LINE:
{
Aast tmp1657_AST = null;
tmp1657_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1657_AST);
match(KW_MSG_LINE);
break;
}
case KW_NOW:
{
Aast tmp1658_AST = null;
tmp1658_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1658_AST);
match(KW_NOW);
break;
}
case KW_NUM_ALIA:
{
Aast tmp1659_AST = null;
tmp1659_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1659_AST);
match(KW_NUM_ALIA);
break;
}
case KW_NUM_DBS:
{
Aast tmp1660_AST = null;
tmp1660_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1660_AST);
match(KW_NUM_DBS);
break;
}
case KW_OPSYS:
{
Aast tmp1661_AST = null;
tmp1661_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1661_AST);
match(KW_OPSYS);
break;
}
case KW_PAGE_NUM:
{
Aast tmp1662_AST = null;
tmp1662_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1662_AST);
match(KW_PAGE_NUM);
break;
}
case KW_PROC_HND:
{
Aast tmp1663_AST = null;
tmp1663_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1663_AST);
match(KW_PROC_HND);
break;
}
case KW_PROC_ST:
{
Aast tmp1664_AST = null;
tmp1664_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1664_AST);
match(KW_PROC_ST);
break;
}
case KW_PROFILER:
{
Aast tmp1665_AST = null;
tmp1665_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1665_AST);
match(KW_PROFILER);
break;
}
case KW_PROGRESS:
{
Aast tmp1666_AST = null;
tmp1666_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1666_AST);
match(KW_PROGRESS);
break;
}
case KW_PROMSGS:
{
Aast tmp1667_AST = null;
tmp1667_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1667_AST);
match(KW_PROMSGS);
break;
}
case KW_PROPATH:
{
Aast tmp1668_AST = null;
tmp1668_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1668_AST);
match(KW_PROPATH);
break;
}
case KW_PROVER:
{
Aast tmp1669_AST = null;
tmp1669_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1669_AST);
match(KW_PROVER);
break;
}
case KW_RCOD_INF:
{
Aast tmp1670_AST = null;
tmp1670_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1670_AST);
match(KW_RCOD_INF);
break;
}
case KW_RETRY:
{
Aast tmp1671_AST = null;
tmp1671_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1671_AST);
match(KW_RETRY);
break;
}
case KW_RTOPSYS:
{
Aast tmp1672_AST = null;
tmp1672_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1672_AST);
match(KW_RTOPSYS);
break;
}
case KW_SCRN_LNS:
{
Aast tmp1673_AST = null;
tmp1673_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1673_AST);
match(KW_SCRN_LNS);
break;
}
case KW_SECUR_P:
{
Aast tmp1674_AST = null;
tmp1674_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1674_AST);
match(KW_SECUR_P);
break;
}
case KW_SELF:
{
Aast tmp1675_AST = null;
tmp1675_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1675_AST);
match(KW_SELF);
break;
}
case KW_SESSION:
{
Aast tmp1676_AST = null;
tmp1676_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1676_AST);
match(KW_SESSION);
break;
}
case KW_SUPER:
{
Aast tmp1677_AST = null;
tmp1677_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1677_AST);
match(KW_SUPER);
break;
}
case KW_TERM:
{
Aast tmp1678_AST = null;
tmp1678_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1678_AST);
match(KW_TERM);
break;
}
case KW_THIS_OBJ:
{
Aast tmp1679_AST = null;
tmp1679_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1679_AST);
match(KW_THIS_OBJ);
break;
}
case KW_THIS_PRC:
{
Aast tmp1680_AST = null;
tmp1680_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1680_AST);
match(KW_THIS_PRC);
break;
}
case KW_TIME:
{
Aast tmp1681_AST = null;
tmp1681_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1681_AST);
match(KW_TIME);
break;
}
case KW_TRANS:
{
Aast tmp1682_AST = null;
tmp1682_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1682_AST);
match(KW_TRANS);
break;
}
case KW_USERID:
{
Aast tmp1683_AST = null;
tmp1683_AST = (Aast)astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp1683_AST);
match(KW_USERID);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
reserved_variables_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = reserved_variables_AST;
}
/**
* Read the following tokens until the <code>RBRACKET</code>, discard these
* and build an <code>EXPRESSION -> NUM_LITERAL</code> subtree with the
* value of 1. This is needed to support bizarre behavior of subscripts in
* a {@link #like_clause}. It is called from {@link #subscript}.
*/
public final void likeSubscript() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast likeSubscript_AST = null;
Token junk = null;
Aast junk_AST = null;
try { // for error handling
{
int _cnt1776=0;
_loop1776:
do {
if ((((LA(1) >= DOT && LA(1) <= JUNK)) && ((LA(2) >= DOT && LA(2) <= JUNK)) && (_tokenSet_3.member(LA(3))))&&( LA(1) != RBRACKET )) {
junk = LT(1);
junk_AST = (Aast)astFactory.create(junk);
matchNot(EOF);
hide(junk);
}
else {
if ( _cnt1776>=1 ) { break _loop1776; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt1776++;
} while (true);
}
likeSubscript_AST = (Aast)currentAST.root;
likeSubscript_AST = (Aast)astFactory.make( (new ASTArray(2)).add((Aast)astFactory.create(EXPRESSION,"expression")).add((Aast)astFactory.make( (new ASTArray(1)).add((Aast)astFactory.create(NUM_LITERAL,"1")))));
currentAST.root = likeSubscript_AST;
currentAST.child = likeSubscript_AST!=null &&likeSubscript_AST.getFirstChild()!=null ?
likeSubscript_AST.getFirstChild() : likeSubscript_AST;
currentAST.advanceChildToEnd();
likeSubscript_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_260);
}
returnAST = likeSubscript_AST;
}
/**
* This rule implements the reference-point construct used in at-phrase.
* It is called from {@link #at_phrase} rule only.
* <p>
* ANTLR detects ambiguity due to the use of non-reserved keywords
* and the potential to use symbols and expressions in the k=1 construct in
* an upper level rule {@link #frame_phrase}. To eliminate the ambiguity
* warning, ANTLR's greedy option had to be explicitly enabled.
* Since greedy is the default, this doesn't change the code generation, it
* only suppresses the warning. <b>Note that this rule checks the k=2
* lookahead before matching the <code>PLUS or MINUS</code> keywords. This
* may be OK but it may also bypass the match in a case where something
* unexpected follows the optional keyword. Since this cannot be proven
* for all cases, watch this code!</b>
*/
public final void ref_point() throws RecognitionException, TokenStreamException {
returnAST = null;
ASTPair currentAST = new ASTPair();
Aast ref_point_AST = null;
try { // for error handling
lvalue();
astFactory.addASTChild(currentAST, returnAST);
{
if ((LA(1)==MINUS||LA(1)==PLUS) && (LA(2)==DEC_LITERAL||LA(2)==HEX_LITERAL||LA(2)==NUM_LITERAL) && (_tokenSet_3.member(LA(3)))) {
{
switch ( LA(1)) {
case PLUS:
{
Aast tmp1684_AST = null;
tmp1684_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1684_AST);
match(PLUS);
break;
}
case MINUS:
{
Aast tmp1685_AST = null;
tmp1685_AST = (Aast)astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp1685_AST);
match(MINUS);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
numeric_literal();
astFactory.addASTChild(currentAST, returnAST);
}
else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_3.member(LA(2))) && (_tokenSet_3.member(LA(3)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
ref_point_AST = (Aast)currentAST.root;
}
catch (RecognitionException ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = ref_point_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[120];
data[0]=320L;
data[3]=49152L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17594333528064L;
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = new long[120];
data[0]=320L;
data[3]=49152L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
private static final long[] mk_tokenSet_2() {
long[] data = new long[80];
data[9]=2304L;
data[10]=8388608L;
data[11]=549755813912L;
data[12]=576742227296911488L;
data[13]=36169534507319552L;
data[14]=9015995347763200L;
data[16]=3377699720527872L;
data[17]=8L;
data[21]=34359738368L;
data[22]=64L;
data[25]=4194304L;
data[28]=262144L;
data[30]=536870912L;
data[32]=6597069766672L;
data[33]=1146884L;
data[35]=576460752303423488L;
data[37]=576461302059237376L;
data[38]=67108864L;
data[39]=4398046511104L;
return data;
}
public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
private static final long[] mk_tokenSet_3() {
long[] data = new long[120];
data[0]=-14L;
for (int i = 1; i<=46; i++) { data[i]=-1L; }
data[47]=31L;
return data;
}
public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
private static final long[] mk_tokenSet_4() {
long[] data = new long[120];
data[0]=320L;
data[3]=49280L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17594333528064L;
return data;
}
public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
private static final long[] mk_tokenSet_5() {
long[] data = new long[120];
data[0]=320L;
data[3]=49152L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592722915328L;
return data;
}
public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
private static final long[] mk_tokenSet_6() {
long[] data = new long[48];
data[0]=2L;
return data;
}
public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
private static final long[] mk_tokenSet_7() {
long[] data = new long[80];
data[9]=2304L;
data[10]=8388608L;
data[12]=281474976710656L;
data[13]=36028797018963968L;
data[14]=8796093022208L;
data[16]=3377699720527872L;
data[28]=262144L;
data[37]=576460752303423488L;
data[38]=67108864L;
data[39]=4398046511104L;
return data;
}
public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
private static final long[] mk_tokenSet_8() {
long[] data = new long[68];
data[32]=6597069766656L;
data[33]=1114116L;
return data;
}
public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
private static final long[] mk_tokenSet_9() {
long[] data = new long[120];
data[0]=320L;
data[3]=1097728L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=26388279066624L;
return data;
}
public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
private static final long[] mk_tokenSet_10() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789022515200L;
return data;
}
public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
private static final long[] mk_tokenSet_11() {
long[] data = new long[120];
data[0]=129362L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30806336602112L;
return data;
}
public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
private static final long[] mk_tokenSet_12() {
long[] data = new long[48];
data[0]=2L;
data[9]=4294967296L;
data[10]=512L;
data[12]=32L;
return data;
}
public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
private static final long[] mk_tokenSet_13() {
long[] data = new long[120];
data[0]=129088L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
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]=16L;
data[3]=4177920L;
data[8]=4294967296L;
data[9]=4398046511104L;
data[10]=2305844246164339785L;
data[11]=307388266754211840L;
data[12]=108086399646826498L;
data[13]=88064546076672L;
data[14]=4157570285568L;
data[26]=72057594037927936L;
data[31]=4611686018427387904L;
data[38]=1048576L;
data[46]=13196287016960L;
return data;
}
public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
private static final long[] mk_tokenSet_15() {
long[] data = new long[120];
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
private static final long[] mk_tokenSet_16() {
long[] data = new long[94];
data[0]=16L;
data[3]=128L;
data[14]=9007199254740992L;
data[22]=64L;
data[25]=1116691496960L;
data[35]=576460752303423488L;
data[39]=268435456L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
private static final long[] mk_tokenSet_17() {
long[] data = new long[94];
data[0]=16L;
data[3]=128L;
data[25]=1099511627776L;
data[46]=134217728L;
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]=16L;
data[3]=128L;
data[22]=17179869184L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
private static final long[] mk_tokenSet_19() {
long[] data = new long[120];
data[9]=36037593111986176L;
data[10]=1048576L;
data[12]=2305843009213693952L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
private static final long[] mk_tokenSet_20() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789148344320L;
return data;
}
public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
private static final long[] mk_tokenSet_21() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
private static final long[] mk_tokenSet_22() {
long[] data = new long[80];
data[0]=16L;
data[8]=297403670400663808L;
data[9]=144240201965764615L;
data[10]=-3449194364608183759L;
data[11]=1129335897456696L;
data[12]=1301735459987324080L;
data[13]=2035989329242948866L;
data[14]=13999948804L;
data[16]=1073741824L;
data[17]=-9223354442521247744L;
data[18]=1342177280L;
data[21]=1L;
data[22]=128L;
data[23]=8L;
data[27]=4096L;
data[31]=22517998136852480L;
data[33]=8796093022208L;
data[34]=281474976710656L;
data[37]=8796093022208L;
data[38]=1152921504606855168L;
data[39]=292734250661184000L;
return data;
}
public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
private static final long[] mk_tokenSet_23() {
long[] data = new long[48];
data[9]=36037593111986176L;
data[10]=1048576L;
data[12]=2305843009213693952L;
return data;
}
public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
private static final long[] mk_tokenSet_24() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
private static final long[] mk_tokenSet_25() {
long[] data = new long[94];
data[0]=16L;
data[46]=872415232L;
return data;
}
public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
private static final long[] mk_tokenSet_26() {
long[] data = new long[94];
data[0]=16L;
data[46]=335544320L;
return data;
}
public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
private static final long[] mk_tokenSet_27() {
long[] data = new long[120];
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
private static final long[] mk_tokenSet_28() {
long[] data = new long[188];
data[0]=-16L;
for (int i = 1; i<=46; i++) { data[i]=-1L; }
data[47]=31L;
return data;
}
public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
private static final long[] mk_tokenSet_29() {
long[] data = new long[94];
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
private static final long[] mk_tokenSet_30() {
long[] data = new long[96];
data[0]=-32L;
for (int i = 1; i<=45; i++) { data[i]=-1L; }
data[46]=-17592186044417L;
data[47]=31L;
return data;
}
public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
private static final long[] mk_tokenSet_31() {
long[] data = new long[94];
data[0]=16L;
data[11]=1L;
data[33]=4L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
private static final long[] mk_tokenSet_32() {
long[] data = new long[94];
data[0]=16L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
private static final long[] mk_tokenSet_33() {
long[] data = new long[94];
data[0]=16L;
data[11]=1L;
data[12]=268435456L;
data[17]=4294967296L;
data[31]=144115188075855872L;
data[32]=67108864L;
data[33]=4L;
data[37]=4398046511104L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
private static final long[] mk_tokenSet_34() {
long[] data = new long[94];
data[0]=16L;
data[14]=9007199254740992L;
data[22]=64L;
data[25]=1116691496960L;
data[35]=576460752303423488L;
data[39]=268435456L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
private static final long[] mk_tokenSet_35() {
long[] data = new long[120];
data[0]=336L;
data[3]=49152L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
private static final long[] mk_tokenSet_36() {
long[] data = new long[48];
data[0]=16L;
return data;
}
public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
private static final long[] mk_tokenSet_37() {
long[] data = new long[120];
data[0]=320L;
data[3]=1097728L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=26388815937536L;
return data;
}
public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
private static final long[] mk_tokenSet_38() {
long[] data = new long[120];
data[0]=320L;
data[3]=1097856L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=26388815937536L;
return data;
}
public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
private static final long[] mk_tokenSet_39() {
long[] data = new long[120];
data[0]=320L;
data[3]=49280L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
private static final long[] mk_tokenSet_40() {
long[] data = new long[120];
data[0]=336L;
data[3]=49280L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17595004616704L;
return data;
}
public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
private static final long[] mk_tokenSet_41() {
long[] data = new long[120];
data[0]=129362L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30807410343936L;
return data;
}
public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
private static final long[] mk_tokenSet_42() {
long[] data = new long[94];
data[0]=16L;
data[11]=8589934593L;
data[21]=2251799813685248L;
data[22]=140737488355328L;
data[33]=4L;
data[46]=671088640L;
return data;
}
public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
private static final long[] mk_tokenSet_43() {
long[] data = new long[94];
data[0]=16L;
data[3]=128L;
data[11]=8589934593L;
data[21]=2251799813685248L;
data[22]=140737488355328L;
data[33]=4L;
data[46]=671088640L;
return data;
}
public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
private static final long[] mk_tokenSet_44() {
long[] data = new long[48];
data[11]=1L;
return data;
}
public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
private static final long[] mk_tokenSet_45() {
long[] data = new long[120];
data[10]=1048576L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
private static final long[] mk_tokenSet_46() {
long[] data = new long[120];
data[0]=129088L;
data[10]=1048576L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
private static final long[] mk_tokenSet_47() {
long[] data = new long[82];
data[8]=576460752303423488L;
data[10]=524288L;
data[14]=72057594037927936L;
data[16]=8388608L;
data[18]=34359929856L;
data[19]=549755813888L;
data[21]=18014398509481984L;
data[26]=532575944704L;
data[29]=2251799813685248L;
data[32]=34359738368L;
data[34]=562949953421312L;
data[40]=2L;
return data;
}
public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
private static final long[] mk_tokenSet_48() {
long[] data = new long[76];
data[11]=67108864L;
data[13]=1125899906842624L;
data[28]=2097152L;
data[35]=2L;
data[37]=576460752303423488L;
return data;
}
public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
private static final long[] mk_tokenSet_49() {
long[] data = new long[120];
data[0]=129344L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
private static final long[] mk_tokenSet_50() {
long[] data = new long[120];
data[10]=64L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
private static final long[] mk_tokenSet_51() {
long[] data = new long[120];
data[8]=648799821322256384L;
data[9]=134217728L;
data[10]=576460752308142080L;
data[11]=576460752370794496L;
data[14]=-1125897759358976L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=52776558133248L;
return data;
}
public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
private static final long[] mk_tokenSet_52() {
long[] data = new long[120];
data[0]=129344L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65973419769856L;
return data;
}
public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
private static final long[] mk_tokenSet_53() {
long[] data = new long[120];
data[0]=320L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
private static final long[] mk_tokenSet_54() {
long[] data = new long[120];
data[8]=4194304L;
data[11]=128L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
private static final long[] mk_tokenSet_55() {
long[] data = new long[120];
data[0]=320L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964704832925936L;
data[9]=2319780420788555104L;
data[10]=2310357483690196101L;
data[11]=-3169407961672843008L;
data[12]=126468430181695744L;
data[13]=-6232886943492016000L;
data[14]=-1121776721460708L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30788506615808L;
return data;
}
public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
private static final long[] mk_tokenSet_56() {
long[] data = new long[78];
data[14]=1L;
data[18]=16777216L;
data[20]=288230376151711744L;
data[22]=2L;
data[33]=1099511627776L;
data[35]=4503599627370496L;
data[37]=8L;
data[38]=562949953421312L;
return data;
}
public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
private static final long[] mk_tokenSet_57() {
long[] data = new long[78];
data[9]=140737488357376L;
data[13]=2305843009213693952L;
data[38]=131072L;
return data;
}
public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
private static final long[] mk_tokenSet_58() {
long[] data = new long[120];
data[0]=129344L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
private static final long[] mk_tokenSet_59() {
long[] data = new long[68];
data[13]=8796093022208L;
data[23]=8L;
data[32]=6597069766656L;
data[33]=1114116L;
return data;
}
public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
private static final long[] mk_tokenSet_60() {
long[] data = new long[94];
data[0]=16L;
data[13]=8796093022208L;
data[23]=8L;
data[46]=671088640L;
return data;
}
public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
private static final long[] mk_tokenSet_61() {
long[] data = new long[120];
data[0]=320L;
data[3]=49152L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17595944140800L;
return data;
}
public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
private static final long[] mk_tokenSet_62() {
long[] data = new long[52];
data[25]=566231040L;
return data;
}
public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
private static final long[] mk_tokenSet_63() {
long[] data = new long[52];
data[21]=648518346341351424L;
data[25]=469762048L;
return data;
}
public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
private static final long[] mk_tokenSet_64() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
private static final long[] mk_tokenSet_65() {
long[] data = new long[94];
data[3]=4177920L;
data[8]=4294967296L;
data[9]=4398046511104L;
data[10]=2305844246164339713L;
data[11]=289356276058685440L;
data[12]=108086399646826496L;
data[13]=88064546076672L;
data[14]=4123168604160L;
data[46]=13196287016960L;
return data;
}
public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
private static final long[] mk_tokenSet_66() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537991408L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
private static final long[] mk_tokenSet_67() {
long[] data = new long[82];
data[13]=8589934656L;
data[40]=112L;
return data;
}
public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
private static final long[] mk_tokenSet_68() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17593259786240L;
return data;
}
public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
private static final long[] mk_tokenSet_69() {
long[] data = new long[78];
data[9]=140737488357632L;
data[10]=8388608L;
data[12]=281474976710656L;
data[13]=2413929400270585856L;
data[16]=3377699720527872L;
data[19]=134217728L;
data[28]=2359296L;
data[37]=576460752303423488L;
data[38]=67239936L;
return data;
}
public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
private static final long[] mk_tokenSet_70() {
long[] data = new long[74];
data[9]=13510798882111488L;
data[12]=70368744701952L;
data[19]=16384L;
data[20]=35184372088832L;
data[22]=4294967296L;
data[33]=8581545984L;
data[36]=35321811107840L;
return data;
}
public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
private static final long[] mk_tokenSet_71() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2306124486371574880L;
data[10]=4513237517467780L;
data[11]=-3458764237731528448L;
data[12]=18030186813456640L;
data[13]=-8646904408308678528L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
private static final long[] mk_tokenSet_72() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17593528221696L;
return data;
}
public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
private static final long[] mk_tokenSet_73() {
long[] data = new long[82];
data[8]=576460752303423488L;
data[18]=263168L;
data[34]=144678138029277184L;
data[40]=13651605089943552L;
return data;
}
public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
private static final long[] mk_tokenSet_74() {
long[] data = new long[120];
data[0]=320L;
data[3]=1114112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=26388279066624L;
return data;
}
public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
private static final long[] mk_tokenSet_75() {
long[] data = new long[94];
data[16]=24L;
data[18]=2251799813685248L;
data[27]=-9223372036854775808L;
data[29]=16777216L;
data[37]=7421932185906577408L;
data[38]=72057594037927940L;
data[46]=1073741824L;
return data;
}
public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
private static final long[] mk_tokenSet_76() {
long[] data = new long[94];
data[3]=1114112L;
data[8]=576460752303423488L;
data[18]=263168L;
data[34]=144678138029277184L;
data[40]=13651605089943552L;
data[46]=8796093022208L;
return data;
}
public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
private static final long[] mk_tokenSet_77() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
private static final long[] mk_tokenSet_78() {
long[] data = new long[78];
data[16]=24L;
data[18]=2251799813685248L;
data[27]=-9223372036854775808L;
data[29]=16777216L;
data[37]=7421932185906577408L;
data[38]=72057594037927940L;
return data;
}
public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
private static final long[] mk_tokenSet_79() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790087868416L;
return data;
}
public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
private static final long[] mk_tokenSet_80() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790356303872L;
return data;
}
public static final BitSet _tokenSet_80 = new BitSet(mk_tokenSet_80());
private static final long[] mk_tokenSet_81() {
long[] data = new long[120];
data[0]=129344L;
data[3]=49152L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17594333528064L;
return data;
}
public static final BitSet _tokenSet_81 = new BitSet(mk_tokenSet_81());
private static final long[] mk_tokenSet_82() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30806193995776L;
return data;
}
public static final BitSet _tokenSet_82 = new BitSet(mk_tokenSet_82());
private static final long[] mk_tokenSet_83() {
long[] data = new long[188];
data[0]=-16L;
for (int i = 1; i<=45; i++) { data[i]=-1L; }
data[46]=-1073741825L;
data[47]=31L;
return data;
}
public static final BitSet _tokenSet_83 = new BitSet(mk_tokenSet_83());
private static final long[] mk_tokenSet_84() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30806193995776L;
return data;
}
public static final BitSet _tokenSet_84 = new BitSet(mk_tokenSet_84());
private static final long[] mk_tokenSet_85() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_85 = new BitSet(mk_tokenSet_85());
private static final long[] mk_tokenSet_86() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65990574473216L;
return data;
}
public static final BitSet _tokenSet_86 = new BitSet(mk_tokenSet_86());
private static final long[] mk_tokenSet_87() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=206158479360L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-246290705285353L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17594333528064L;
return data;
}
public static final BitSet _tokenSet_87 = new BitSet(mk_tokenSet_87());
private static final long[] mk_tokenSet_88() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=49152L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_88 = new BitSet(mk_tokenSet_88());
private static final long[] mk_tokenSet_89() {
long[] data = new long[120];
data[3]=206158430208L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17594333528064L;
return data;
}
public static final BitSet _tokenSet_89 = new BitSet(mk_tokenSet_89());
private static final long[] mk_tokenSet_90() {
long[] data = new long[120];
data[7]=35184271425280L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_90 = new BitSet(mk_tokenSet_90());
private static final long[] mk_tokenSet_91() {
long[] data = new long[48];
data[0]=16L;
data[11]=17592186044416L;
data[14]=4398046511104L;
return data;
}
public static final BitSet _tokenSet_91 = new BitSet(mk_tokenSet_91());
private static final long[] mk_tokenSet_92() {
long[] data = new long[94];
data[0]=16L;
data[8]=792633810473713664L;
data[9]=274894684160L;
data[10]=576460752308142080L;
data[11]=285873090592768L;
data[12]=33554432L;
data[14]=72062011411791936L;
data[16]=8388608L;
data[18]=34359929856L;
data[19]=549755813888L;
data[21]=18014398509481984L;
data[26]=532575944704L;
data[29]=2251799813685248L;
data[30]=2305843009213693952L;
data[32]=34359738368L;
data[34]=562949953421312L;
data[39]=274877906944L;
data[40]=2L;
data[46]=35184380477440L;
return data;
}
public static final BitSet _tokenSet_92 = new BitSet(mk_tokenSet_92());
private static final long[] mk_tokenSet_93() {
long[] data = new long[120];
data[0]=129362L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65990708690944L;
return data;
}
public static final BitSet _tokenSet_93 = new BitSet(mk_tokenSet_93());
private static final long[] mk_tokenSet_94() {
long[] data = new long[120];
data[0]=336L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1783425457136349424L;
data[9]=2319780420788555104L;
data[10]=2310357483694914693L;
data[11]=-3169407961672843007L;
data[12]=126468430181695744L;
data[13]=-6222753844330432384L;
data[14]=-1117376527465955L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30788473061376L;
return data;
}
public static final BitSet _tokenSet_94 = new BitSet(mk_tokenSet_94());
private static final long[] mk_tokenSet_95() {
long[] data = new long[120];
data[0]=336L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964704832925936L;
data[9]=2319780420788555104L;
data[10]=2310357483690196101L;
data[11]=-3169407961672843007L;
data[12]=126468430181695744L;
data[13]=-6222753844330432384L;
data[14]=-1117378674949603L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30788473061376L;
return data;
}
public static final BitSet _tokenSet_95 = new BitSet(mk_tokenSet_95());
private static final long[] mk_tokenSet_96() {
long[] data = new long[96];
data[0]=-288L;
for (int i = 1; i<=46; i++) { data[i]=-1L; }
data[47]=31L;
return data;
}
public static final BitSet _tokenSet_96 = new BitSet(mk_tokenSet_96());
private static final long[] mk_tokenSet_97() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1121501843553764L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_97 = new BitSet(mk_tokenSet_97());
private static final long[] mk_tokenSet_98() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1999598511011672304L;
data[9]=2319776297636728160L;
data[10]=580973989833998468L;
data[11]=-3458478364640935680L;
data[12]=18382030568423680L;
data[13]=-6232975008038092672L;
data[14]=-1121482516200868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=52776566521856L;
return data;
}
public static final BitSet _tokenSet_98 = new BitSet(mk_tokenSet_98());
private static final long[] mk_tokenSet_99() {
long[] data = new long[48];
data[0]=16L;
data[14]=4398046511104L;
return data;
}
public static final BitSet _tokenSet_99 = new BitSet(mk_tokenSet_99());
private static final long[] mk_tokenSet_100() {
long[] data = new long[120];
data[0]=320L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964704832925936L;
data[9]=2319780420788555104L;
data[10]=2310357483690196101L;
data[11]=-3169407961672843008L;
data[12]=126468430181695744L;
data[13]=-6232886943492016000L;
data[14]=-1121776721460708L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30788473061376L;
return data;
}
public static final BitSet _tokenSet_100 = new BitSet(mk_tokenSet_100());
private static final long[] mk_tokenSet_101() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789416779776L;
return data;
}
public static final BitSet _tokenSet_101 = new BitSet(mk_tokenSet_101());
private static final long[] mk_tokenSet_102() {
long[] data = new long[120];
data[0]=129088L;
data[9]=18014398509481984L;
data[10]=65536L;
data[11]=524288L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_102 = new BitSet(mk_tokenSet_102());
private static final long[] mk_tokenSet_103() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789416779776L;
return data;
}
public static final BitSet _tokenSet_103 = new BitSet(mk_tokenSet_103());
private static final long[] mk_tokenSet_104() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537991408L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1121501843553764L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_104 = new BitSet(mk_tokenSet_104());
private static final long[] mk_tokenSet_105() {
long[] data = new long[48];
data[0]=16L;
data[10]=8L;
data[11]=17592186044416L;
data[14]=4398080065536L;
return data;
}
public static final BitSet _tokenSet_105 = new BitSet(mk_tokenSet_105());
private static final long[] mk_tokenSet_106() {
long[] data = new long[82];
data[8]=576460752303423488L;
data[10]=524288L;
data[12]=4L;
data[14]=72057594037927936L;
data[16]=8388608L;
data[18]=34359929856L;
data[19]=549755813888L;
data[21]=18014398509481984L;
data[26]=532575944704L;
data[29]=2251799813685248L;
data[32]=34359738368L;
data[34]=562949953421312L;
data[40]=2L;
return data;
}
public static final BitSet _tokenSet_106 = new BitSet(mk_tokenSet_106());
private static final long[] mk_tokenSet_107() {
long[] data = new long[48];
data[12]=1649267441664L;
data[13]=8796093022208L;
data[14]=4194304L;
return data;
}
public static final BitSet _tokenSet_107 = new BitSet(mk_tokenSet_107());
private static final long[] mk_tokenSet_108() {
long[] data = new long[120];
data[3]=192L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34659979231232L;
return data;
}
public static final BitSet _tokenSet_108 = new BitSet(mk_tokenSet_108());
private static final long[] mk_tokenSet_109() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34660247666688L;
return data;
}
public static final BitSet _tokenSet_109 = new BitSet(mk_tokenSet_109());
private static final long[] mk_tokenSet_110() {
long[] data = new long[48];
data[8]=65536L;
data[9]=70377602547714L;
data[10]=9007199254741024L;
for (int i = 11; i<=12; i++) { data[i]=32L; }
data[13]=1099511628800L;
data[14]=4194304L;
data[17]=-9223372036854775808L;
return data;
}
public static final BitSet _tokenSet_110 = new BitSet(mk_tokenSet_110());
private static final long[] mk_tokenSet_111() {
long[] data = new long[120];
data[0]=129344L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30793309093888L;
return data;
}
public static final BitSet _tokenSet_111 = new BitSet(mk_tokenSet_111());
private static final long[] mk_tokenSet_112() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790087868416L;
return data;
}
public static final BitSet _tokenSet_112 = new BitSet(mk_tokenSet_112());
private static final long[] mk_tokenSet_113() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_113 = new BitSet(mk_tokenSet_113());
private static final long[] mk_tokenSet_114() {
long[] data = new long[94];
data[11]=17592186044416L;
data[13]=131072L;
data[18]=134217728L;
data[21]=562949953421312L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_114 = new BitSet(mk_tokenSet_114());
private static final long[] mk_tokenSet_115() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2896236775045467488L;
data[10]=4513237525856388L;
data[11]=-3458746645545484032L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125882710195684L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592320262144L;
return data;
}
public static final BitSet _tokenSet_115 = new BitSet(mk_tokenSet_115());
private static final long[] mk_tokenSet_116() {
long[] data = new long[76];
for (int i = 8; i<=9; i++) { data[i]=67108864L; }
data[11]=21990500990976L;
data[12]=1073741824L;
data[13]=144115188075986944L;
data[14]=457396904263680L;
data[22]=4611686018427387904L;
data[26]=4398046511104L;
data[29]=2147483648L;
data[31]=108086391056891904L;
data[37]=4503599627370496L;
return data;
}
public static final BitSet _tokenSet_116 = new BitSet(mk_tokenSet_116());
private static final long[] mk_tokenSet_117() {
long[] data = new long[94];
data[0]=16L;
data[8]=16777216L;
data[11]=17592186044417L;
data[14]=2048L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_117 = new BitSet(mk_tokenSet_117());
private static final long[] mk_tokenSet_118() {
long[] data = new long[94];
data[0]=16L;
data[8]=16777216L;
data[11]=17592186044416L;
data[14]=2048L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_118 = new BitSet(mk_tokenSet_118());
private static final long[] mk_tokenSet_119() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65973394604032L;
return data;
}
public static final BitSet _tokenSet_119 = new BitSet(mk_tokenSet_119());
private static final long[] mk_tokenSet_120() {
long[] data = new long[120];
data[0]=129360L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65974468345856L;
return data;
}
public static final BitSet _tokenSet_120 = new BitSet(mk_tokenSet_120());
private static final long[] mk_tokenSet_121() {
long[] data = new long[120];
data[0]=336L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964704832958704L;
data[9]=2319780420788555104L;
data[10]=2310357483690196101L;
data[11]=-3169407961672843007L;
data[12]=126468430181695744L;
data[13]=-6222753844330432384L;
data[14]=-1117378674949603L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30788473061376L;
return data;
}
public static final BitSet _tokenSet_121 = new BitSet(mk_tokenSet_121());
private static final long[] mk_tokenSet_122() {
long[] data = new long[120];
data[0]=320L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964704832925936L;
data[9]=2319780420788555104L;
data[10]=2310357483690196101L;
data[11]=-3169407961672843008L;
data[12]=126468430181695744L;
data[13]=-6222753844330432384L;
data[14]=-1121776721460707L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30788473061376L;
return data;
}
public static final BitSet _tokenSet_122 = new BitSet(mk_tokenSet_122());
private static final long[] mk_tokenSet_123() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537991408L;
data[9]=2319776022742044000L;
data[10]=4513237525856452L;
data[11]=-3449756901037833975L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_123 = new BitSet(mk_tokenSet_123());
private static final long[] mk_tokenSet_124() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856452L;
data[11]=-3458764237731528440L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_124 = new BitSet(mk_tokenSet_124());
private static final long[] mk_tokenSet_125() {
long[] data = new long[120];
data[0]=129360L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776039921913184L;
data[10]=4513237525856388L;
data[11]=-3458183695592062720L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899889540580L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17609365913600L;
return data;
}
public static final BitSet _tokenSet_125 = new BitSet(mk_tokenSet_125());
private static final long[] mk_tokenSet_126() {
long[] data = new long[120];
data[0]=129360L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776039921913184L;
data[10]=4513237525856388L;
data[11]=-3458183695592062720L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17609365913600L;
return data;
}
public static final BitSet _tokenSet_126 = new BitSet(mk_tokenSet_126());
private static final long[] mk_tokenSet_127() {
long[] data = new long[120];
data[0]=129360L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458183695592062720L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17609365913600L;
return data;
}
public static final BitSet _tokenSet_127 = new BitSet(mk_tokenSet_127());
private static final long[] mk_tokenSet_128() {
long[] data = new long[48];
data[0]=16L;
data[10]=8L;
data[11]=580542139465728L;
return data;
}
public static final BitSet _tokenSet_128 = new BitSet(mk_tokenSet_128());
private static final long[] mk_tokenSet_129() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458183695592062720L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17609365913600L;
return data;
}
public static final BitSet _tokenSet_129 = new BitSet(mk_tokenSet_129());
private static final long[] mk_tokenSet_130() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513254705725572L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064804L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_130 = new BitSet(mk_tokenSet_130());
private static final long[] mk_tokenSet_131() {
long[] data = new long[78];
data[10]=17179869184L;
data[14]=64L;
data[17]=-9223372036854775808L;
data[38]=274877906944L;
return data;
}
public static final BitSet _tokenSet_131 = new BitSet(mk_tokenSet_131());
private static final long[] mk_tokenSet_132() {
long[] data = new long[48];
data[8]=16777216L;
data[9]=8589934594L;
data[10]=512L;
data[14]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_132 = new BitSet(mk_tokenSet_132());
private static final long[] mk_tokenSet_133() {
long[] data = new long[94];
data[8]=9007267974217728L;
data[9]=576495936675512320L;
data[10]=576460752303424000L;
data[11]=549755813888L;
data[12]=35184372088832L;
data[13]=256L;
data[14]=2251799815782400L;
data[15]=34359738368L;
data[16]=567348536803968L;
data[17]=-9223363240761622528L;
data[18]=140737756790784L;
data[19]=-4323455642245660672L;
data[20]=1729382256910274604L;
data[21]=8796262957056L;
data[22]=24576L;
data[23]=8L;
data[24]=4611686024869838848L;
data[25]=1116892707587883008L;
data[26]=360287970189639680L;
data[27]=4503599627370496L;
data[29]=144115188075855872L;
data[30]=84672512L;
data[31]=38280596832649216L;
data[32]=162130067755898624L;
data[33]=4503599627370496L;
data[34]=343614178304L;
data[35]=77594640L;
data[36]=128L;
data[37]=43980465111040L;
data[38]=9007199254773760L;
data[39]=128L;
data[46]=2147483648L;
return data;
}
public static final BitSet _tokenSet_133 = new BitSet(mk_tokenSet_133());
private static final long[] mk_tokenSet_134() {
long[] data = new long[120];
data[0]=129362L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34660113448960L;
return data;
}
public static final BitSet _tokenSet_134 = new BitSet(mk_tokenSet_134());
private static final long[] mk_tokenSet_135() {
long[] data = new long[48];
data[0]=16L;
data[8]=17179869184L;
data[11]=4503737066323969L;
return data;
}
public static final BitSet _tokenSet_135 = new BitSet(mk_tokenSet_135());
private static final long[] mk_tokenSet_136() {
long[] data = new long[120];
data[0]=336L;
data[2]=545259520L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_136 = new BitSet(mk_tokenSet_136());
private static final long[] mk_tokenSet_137() {
long[] data = new long[84];
data[12]=268435456L;
data[13]=562949953421312L;
data[36]=-9223372036854775808L;
data[41]=4L;
return data;
}
public static final BitSet _tokenSet_137 = new BitSet(mk_tokenSet_137());
private static final long[] mk_tokenSet_138() {
long[] data = new long[48];
data[11]=1099528404992L;
data[13]=384L;
return data;
}
public static final BitSet _tokenSet_138 = new BitSet(mk_tokenSet_138());
private static final long[] mk_tokenSet_139() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856452L;
data[11]=-3458764237731528439L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_139 = new BitSet(mk_tokenSet_139());
private static final long[] mk_tokenSet_140() {
long[] data = new long[120];
data[0]=16L;
data[3]=192L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34659979231232L;
return data;
}
public static final BitSet _tokenSet_140 = new BitSet(mk_tokenSet_140());
private static final long[] mk_tokenSet_141() {
long[] data = new long[120];
data[0]=129362L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34660381884416L;
return data;
}
public static final BitSet _tokenSet_141 = new BitSet(mk_tokenSet_141());
private static final long[] mk_tokenSet_142() {
long[] data = new long[120];
data[3]=192L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34660247666688L;
return data;
}
public static final BitSet _tokenSet_142 = new BitSet(mk_tokenSet_142());
private static final long[] mk_tokenSet_143() {
long[] data = new long[120];
data[0]=320L;
data[3]=192L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=34660247666688L;
return data;
}
public static final BitSet _tokenSet_143 = new BitSet(mk_tokenSet_143());
private static final long[] mk_tokenSet_144() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789148344320L;
return data;
}
public static final BitSet _tokenSet_144 = new BitSet(mk_tokenSet_144());
private static final long[] mk_tokenSet_145() {
long[] data = new long[76];
data[12]=4503599627370496L;
data[21]=136314880L;
data[37]=8796093022208L;
return data;
}
public static final BitSet _tokenSet_145 = new BitSet(mk_tokenSet_145());
private static final long[] mk_tokenSet_146() {
long[] data = new long[94];
data[15]=8796093022208L;
data[16]=134217728L;
data[17]=4096L;
data[19]=70368744177664L;
data[24]=2305843009213693952L;
data[25]=524288L;
data[26]=67108864L;
data[27]=70368744177664L;
data[30]=344543118298710016L;
data[31]=1125899906842624L;
data[34]=8589934592L;
data[35]=144115188075855872L;
data[46]=1073741824L;
return data;
}
public static final BitSet _tokenSet_146 = new BitSet(mk_tokenSet_146());
private static final long[] mk_tokenSet_147() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789148344320L;
return data;
}
public static final BitSet _tokenSet_147 = new BitSet(mk_tokenSet_147());
private static final long[] mk_tokenSet_148() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790490521600L;
return data;
}
public static final BitSet _tokenSet_148 = new BitSet(mk_tokenSet_148());
private static final long[] mk_tokenSet_149() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790490521600L;
return data;
}
public static final BitSet _tokenSet_149 = new BitSet(mk_tokenSet_149());
private static final long[] mk_tokenSet_150() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528440L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_150 = new BitSet(mk_tokenSet_150());
private static final long[] mk_tokenSet_151() {
long[] data = new long[120];
data[0]=64L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_151 = new BitSet(mk_tokenSet_151());
private static final long[] mk_tokenSet_152() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30793309093888L;
return data;
}
public static final BitSet _tokenSet_152 = new BitSet(mk_tokenSet_152());
private static final long[] mk_tokenSet_153() {
long[] data = new long[64];
data[0]=16L;
data[10]=1048576L;
data[14]=32768L;
data[31]=562949953421312L;
return data;
}
public static final BitSet _tokenSet_153 = new BitSet(mk_tokenSet_153());
private static final long[] mk_tokenSet_154() {
long[] data = new long[76];
data[17]=34359738368L;
data[19]=1125904201809920L;
data[20]=68719476736L;
data[22]=68719476736L;
data[26]=2L;
data[27]=17592186044416L;
data[31]=17179869184L;
data[33]=35184372088832L;
data[37]=64L;
return data;
}
public static final BitSet _tokenSet_154 = new BitSet(mk_tokenSet_154());
private static final long[] mk_tokenSet_155() {
long[] data = new long[48];
data[0]=16L;
data[8]=72339069014638592L;
data[9]=536870912L;
data[10]=4194304L;
data[11]=576460752303685632L;
return data;
}
public static final BitSet _tokenSet_155 = new BitSet(mk_tokenSet_155());
private static final long[] mk_tokenSet_156() {
long[] data = new long[48];
data[8]=72339069014638592L;
data[9]=536870912L;
data[10]=4194304L;
data[11]=576460752303685632L;
return data;
}
public static final BitSet _tokenSet_156 = new BitSet(mk_tokenSet_156());
private static final long[] mk_tokenSet_157() {
long[] data = new long[120];
data[0]=80L;
data[8]=72339069014638592L;
data[9]=536870912L;
data[10]=4194304L;
data[11]=576460752303685632L;
data[14]=-1125899906777088L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_157 = new BitSet(mk_tokenSet_157());
private static final long[] mk_tokenSet_158() {
long[] data = new long[120];
data[0]=80L;
data[14]=-1125899906777088L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_158 = new BitSet(mk_tokenSet_158());
private static final long[] mk_tokenSet_159() {
long[] data = new long[120];
data[0]=80L;
data[8]=4194304L;
data[14]=-1125899906777088L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_159 = new BitSet(mk_tokenSet_159());
private static final long[] mk_tokenSet_160() {
long[] data = new long[94];
data[0]=16L;
data[10]=1048576L;
data[14]=4398046543872L;
data[31]=562949953421312L;
data[46]=1073741824L;
return data;
}
public static final BitSet _tokenSet_160 = new BitSet(mk_tokenSet_160());
private static final long[] mk_tokenSet_161() {
long[] data = new long[48];
data[0]=16L;
data[10]=17179869184L;
return data;
}
public static final BitSet _tokenSet_161 = new BitSet(mk_tokenSet_161());
private static final long[] mk_tokenSet_162() {
long[] data = new long[48];
data[8]=32768L;
data[9]=8589934592L;
data[11]=32L;
data[12]=16L;
data[13]=1099511627776L;
data[14]=4194304L;
return data;
}
public static final BitSet _tokenSet_162 = new BitSet(mk_tokenSet_162());
private static final long[] mk_tokenSet_163() {
long[] data = new long[48];
data[10]=17179869184L;
data[14]=64L;
return data;
}
public static final BitSet _tokenSet_163 = new BitSet(mk_tokenSet_163());
private static final long[] mk_tokenSet_164() {
long[] data = new long[48];
data[13]=1099511627776L;
data[14]=536870912L;
return data;
}
public static final BitSet _tokenSet_164 = new BitSet(mk_tokenSet_164());
private static final long[] mk_tokenSet_165() {
long[] data = new long[48];
data[10]=17179869184L;
data[11]=64L;
return data;
}
public static final BitSet _tokenSet_165 = new BitSet(mk_tokenSet_165());
private static final long[] mk_tokenSet_166() {
long[] data = new long[94];
data[0]=16L;
data[10]=324259173171724288L;
data[14]=4432406282240L;
data[31]=562949953421312L;
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_166 = new BitSet(mk_tokenSet_166());
private static final long[] mk_tokenSet_167() {
long[] data = new long[70];
data[11]=1024L;
data[25]=1125899906842624L;
data[26]=72057594037927936L;
data[34]=68719476736L;
return data;
}
public static final BitSet _tokenSet_167 = new BitSet(mk_tokenSet_167());
private static final long[] mk_tokenSet_168() {
long[] data = new long[94];
data[0]=16L;
data[10]=324259173171724288L;
data[14]=4432406282240L;
data[31]=562949953421312L;
data[46]=1073741824L;
return data;
}
public static final BitSet _tokenSet_168 = new BitSet(mk_tokenSet_168());
private static final long[] mk_tokenSet_169() {
long[] data = new long[48];
data[0]=16L;
data[14]=34359738368L;
return data;
}
public static final BitSet _tokenSet_169 = new BitSet(mk_tokenSet_169());
private static final long[] mk_tokenSet_170() {
long[] data = new long[94];
data[0]=16L;
data[14]=34359738368L;
data[46]=268435456L;
return data;
}
public static final BitSet _tokenSet_170 = new BitSet(mk_tokenSet_170());
private static final long[] mk_tokenSet_171() {
long[] data = new long[94];
data[0]=16L;
data[14]=34359738368L;
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_171 = new BitSet(mk_tokenSet_171());
private static final long[] mk_tokenSet_172() {
long[] data = new long[94];
data[8]=792633810473713664L;
data[9]=274894684160L;
data[10]=576460769488011264L;
data[11]=285873090592832L;
data[12]=33554432L;
data[14]=72057613365280832L;
data[16]=8388608L;
data[18]=34359929856L;
data[19]=549755813888L;
data[21]=18014398509481984L;
data[26]=532575944704L;
data[29]=2251799813685248L;
data[30]=2305843009213693952L;
data[32]=34359738368L;
data[34]=562949953421312L;
data[39]=274877906944L;
data[40]=2L;
data[46]=35184648912896L;
return data;
}
public static final BitSet _tokenSet_172 = new BitSet(mk_tokenSet_172());
private static final long[] mk_tokenSet_173() {
long[] data = new long[120];
data[0]=129344L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65973663039488L;
return data;
}
public static final BitSet _tokenSet_173 = new BitSet(mk_tokenSet_173());
private static final long[] mk_tokenSet_174() {
long[] data = new long[94];
data[10]=17179869184L;
data[11]=64L;
data[46]=268435456L;
return data;
}
public static final BitSet _tokenSet_174 = new BitSet(mk_tokenSet_174());
private static final long[] mk_tokenSet_175() {
long[] data = new long[94];
data[0]=16L;
data[10]=324259173171724288L;
data[11]=1024L;
data[12]=16L;
data[14]=4432406282240L;
data[25]=1125899906842624L;
data[26]=72057594037927936L;
data[31]=562949953421312L;
data[34]=68719476736L;
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_175 = new BitSet(mk_tokenSet_175());
private static final long[] mk_tokenSet_176() {
long[] data = new long[94];
data[0]=16L;
data[10]=324259173171724288L;
data[11]=1024L;
data[14]=4432406282240L;
data[25]=1125899906842624L;
data[26]=72057594037927936L;
data[31]=562949953421312L;
data[46]=1073741824L;
return data;
}
public static final BitSet _tokenSet_176 = new BitSet(mk_tokenSet_176());
private static final long[] mk_tokenSet_177() {
long[] data = new long[94];
data[0]=16L;
data[10]=17179869184L;
data[46]=268435456L;
return data;
}
public static final BitSet _tokenSet_177 = new BitSet(mk_tokenSet_177());
private static final long[] mk_tokenSet_178() {
long[] data = new long[76];
data[0]=16L;
for (int i = 8; i<=9; i++) { data[i]=67108864L; }
data[11]=21990500990976L;
data[12]=1073741824L;
data[13]=144115188075986944L;
data[14]=457396904263680L;
data[22]=4611686018427387904L;
data[26]=4398046511104L;
data[29]=2147483648L;
data[31]=108086391056891904L;
data[37]=4503599627370496L;
return data;
}
public static final BitSet _tokenSet_178 = new BitSet(mk_tokenSet_178());
private static final long[] mk_tokenSet_179() {
long[] data = new long[76];
data[0]=16L;
for (int i = 8; i<=9; i++) { data[i]=67108864L; }
data[11]=21990500990976L;
data[12]=1073741824L;
data[13]=144115188075986944L;
data[14]=457396904263680L;
data[15]=8589934592L;
data[22]=4611686018427387904L;
data[26]=4398046511104L;
data[29]=2147483648L;
data[31]=108086391056891904L;
data[32]=10240L;
data[37]=4503599627370496L;
return data;
}
public static final BitSet _tokenSet_179 = new BitSet(mk_tokenSet_179());
private static final long[] mk_tokenSet_180() {
long[] data = new long[48];
data[0]=16L;
data[11]=1L;
data[14]=4398046511104L;
return data;
}
public static final BitSet _tokenSet_180 = new BitSet(mk_tokenSet_180());
private static final long[] mk_tokenSet_181() {
long[] data = new long[120];
data[0]=336L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1999598515306639600L;
data[9]=2319780695683239264L;
data[10]=2886818235998338181L;
data[11]=-3169122088582250239L;
data[12]=126468430215250176L;
data[13]=-6222753844330432384L;
data[14]=-1117359347596707L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65973927280640L;
return data;
}
public static final BitSet _tokenSet_181 = new BitSet(mk_tokenSet_181());
private static final long[] mk_tokenSet_182() {
long[] data = new long[120];
data[0]=336L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964704832925936L;
data[9]=2319780420788555104L;
data[10]=2310357483690196101L;
data[11]=-3169407961672843007L;
data[12]=126468430181695744L;
data[13]=-6222753844330432384L;
data[14]=-1117378674949603L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789546803200L;
return data;
}
public static final BitSet _tokenSet_182 = new BitSet(mk_tokenSet_182());
private static final long[] mk_tokenSet_183() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65974468345856L;
return data;
}
public static final BitSet _tokenSet_183 = new BitSet(mk_tokenSet_183());
private static final long[] mk_tokenSet_184() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65973394604032L;
return data;
}
public static final BitSet _tokenSet_184 = new BitSet(mk_tokenSet_184());
private static final long[] mk_tokenSet_185() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856388L;
data[11]=-3458764237731528448L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17609365913600L;
return data;
}
public static final BitSet _tokenSet_185 = new BitSet(mk_tokenSet_185());
private static final long[] mk_tokenSet_186() {
long[] data = new long[48];
data[0]=16L;
data[11]=580542139465728L;
return data;
}
public static final BitSet _tokenSet_186 = new BitSet(mk_tokenSet_186());
private static final long[] mk_tokenSet_187() {
long[] data = new long[48];
data[0]=16L;
data[11]=17592186044416L;
data[14]=64L;
return data;
}
public static final BitSet _tokenSet_187 = new BitSet(mk_tokenSet_187());
private static final long[] mk_tokenSet_188() {
long[] data = new long[48];
data[14]=64L;
return data;
}
public static final BitSet _tokenSet_188 = new BitSet(mk_tokenSet_188());
private static final long[] mk_tokenSet_189() {
long[] data = new long[62];
data[0]=16L;
data[11]=17592186044416L;
data[18]=8796093022208L;
data[30]=2199023255552L;
return data;
}
public static final BitSet _tokenSet_189 = new BitSet(mk_tokenSet_189());
private static final long[] mk_tokenSet_190() {
long[] data = new long[80];
data[0]=16L;
data[10]=524288L;
data[11]=2269400589664256L;
data[15]=8589934592L;
data[16]=33554432L;
data[18]=8796093022336L;
data[20]=281474976710656L;
data[26]=2199560126464L;
data[27]=8388608L;
data[30]=72567767433216L;
data[31]=1024L;
data[32]=70368744196096L;
data[39]=8L;
return data;
}
public static final BitSet _tokenSet_190 = new BitSet(mk_tokenSet_190());
private static final long[] mk_tokenSet_191() {
long[] data = new long[76];
data[0]=16L;
data[10]=1048576L;
data[11]=17592186044416L;
data[14]=64L;
data[18]=8796093022208L;
data[30]=2199023255552L;
data[37]=137438953472L;
return data;
}
public static final BitSet _tokenSet_191 = new BitSet(mk_tokenSet_191());
private static final long[] mk_tokenSet_192() {
long[] data = new long[76];
data[10]=1048576L;
data[14]=64L;
data[37]=137438953472L;
return data;
}
public static final BitSet _tokenSet_192 = new BitSet(mk_tokenSet_192());
private static final long[] mk_tokenSet_193() {
long[] data = new long[48];
data[9]=576460752303423488L;
data[12]=16L;
return data;
}
public static final BitSet _tokenSet_193 = new BitSet(mk_tokenSet_193());
private static final long[] mk_tokenSet_194() {
long[] data = new long[120];
data[14]=-1125899772624896L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_194 = new BitSet(mk_tokenSet_194());
private static final long[] mk_tokenSet_195() {
long[] data = new long[48];
data[12]=2L;
return data;
}
public static final BitSet _tokenSet_195 = new BitSet(mk_tokenSet_195());
private static final long[] mk_tokenSet_196() {
long[] data = new long[120];
data[0]=320L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1206964700537958640L;
data[9]=2319776022742044000L;
data[10]=4513237525856452L;
data[11]=-3458764237731528440L;
data[12]=18382030534869248L;
data[13]=-6232975008038092672L;
data[14]=-1125899890064868L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592454479872L;
return data;
}
public static final BitSet _tokenSet_196 = new BitSet(mk_tokenSet_196());
private static final long[] mk_tokenSet_197() {
long[] data = new long[48];
data[0]=16L;
data[11]=18141941858304L;
data[15]=137438953472L;
data[16]=16384L;
data[20]=4194304L;
return data;
}
public static final BitSet _tokenSet_197 = new BitSet(mk_tokenSet_197());
private static final long[] mk_tokenSet_198() {
long[] data = new long[54];
data[26]=4294967296L;
return data;
}
public static final BitSet _tokenSet_198 = new BitSet(mk_tokenSet_198());
private static final long[] mk_tokenSet_199() {
long[] data = new long[48];
data[14]=134217728L;
return data;
}
public static final BitSet _tokenSet_199 = new BitSet(mk_tokenSet_199());
private static final long[] mk_tokenSet_200() {
long[] data = new long[48];
data[0]=16L;
data[11]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_200 = new BitSet(mk_tokenSet_200());
private static final long[] mk_tokenSet_201() {
long[] data = new long[80];
data[10]=524288L;
data[11]=2269400589664256L;
data[15]=8589934592L;
data[16]=33554432L;
data[18]=8796093022336L;
data[20]=281474976710656L;
data[26]=2199560126464L;
data[27]=8388608L;
data[30]=72567767433216L;
data[31]=1024L;
data[32]=70368744196096L;
data[39]=8L;
return data;
}
public static final BitSet _tokenSet_201 = new BitSet(mk_tokenSet_201());
private static final long[] mk_tokenSet_202() {
long[] data = new long[96];
data[0]=-32L;
for (int i = 1; i<=13; i++) { data[i]=-1L; }
data[14]=-134217729L;
for (int i = 15; i<=45; i++) { data[i]=-1L; }
data[46]=-2147483649L;
data[47]=31L;
return data;
}
public static final BitSet _tokenSet_202 = new BitSet(mk_tokenSet_202());
private static final long[] mk_tokenSet_203() {
long[] data = new long[66];
data[10]=524288L;
data[15]=8589934592L;
data[18]=128L;
data[26]=2199560126464L;
data[31]=1024L;
data[32]=70368744196096L;
return data;
}
public static final BitSet _tokenSet_203 = new BitSet(mk_tokenSet_203());
private static final long[] mk_tokenSet_204() {
long[] data = new long[94];
data[0]=16L;
data[3]=4177920L;
data[8]=4294967296L;
data[9]=4398046511104L;
data[10]=2305844246164864001L;
data[11]=291625676648349696L;
data[12]=108086399646826496L;
data[13]=88064546076672L;
data[14]=4123302821888L;
data[15]=8589934592L;
data[16]=33554432L;
data[18]=8796093022336L;
data[20]=281474976710656L;
data[26]=2199560126464L;
data[27]=8388608L;
data[30]=72567767433216L;
data[31]=1024L;
data[32]=70368744196096L;
data[39]=8L;
data[46]=13196287016960L;
return data;
}
public static final BitSet _tokenSet_204 = new BitSet(mk_tokenSet_204());
private static final long[] mk_tokenSet_205() {
long[] data = new long[80];
data[0]=16L;
data[10]=524288L;
data[11]=2269400589664256L;
data[15]=8589934592L;
data[16]=33554432L;
data[18]=8796093022336L;
data[20]=281474976710656L;
data[26]=2199562223616L;
data[27]=8388608L;
data[30]=72567767433216L;
data[31]=1024L;
data[32]=70368744196096L;
data[37]=16777216L;
data[38]=8388608L;
data[39]=8L;
return data;
}
public static final BitSet _tokenSet_205 = new BitSet(mk_tokenSet_205());
private static final long[] mk_tokenSet_206() {
long[] data = new long[76];
data[25]=844424930131968L;
data[37]=7L;
return data;
}
public static final BitSet _tokenSet_206 = new BitSet(mk_tokenSet_206());
private static final long[] mk_tokenSet_207() {
long[] data = new long[78];
data[16]=3298534883328L;
data[26]=72057594037927936L;
data[31]=16L;
data[34]=68719476736L;
data[38]=4503599627370496L;
return data;
}
public static final BitSet _tokenSet_207 = new BitSet(mk_tokenSet_207());
private static final long[] mk_tokenSet_208() {
long[] data = new long[120];
data[0]=336L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790230474752L;
return data;
}
public static final BitSet _tokenSet_208 = new BitSet(mk_tokenSet_208());
private static final long[] mk_tokenSet_209() {
long[] data = new long[80];
data[17]=256L;
data[20]=68719476736L;
data[22]=68719476736L;
data[27]=140737488355328L;
data[36]=36028797018963968L;
data[39]=6144L;
return data;
}
public static final BitSet _tokenSet_209 = new BitSet(mk_tokenSet_209());
private static final long[] mk_tokenSet_210() {
long[] data = new long[58];
data[0]=16L;
data[8]=9345848836096L;
data[12]=2251799813685248L;
data[18]=128L;
data[25]=1073741824L;
data[28]=512L;
return data;
}
public static final BitSet _tokenSet_210 = new BitSet(mk_tokenSet_210());
private static final long[] mk_tokenSet_211() {
long[] data = new long[70];
data[0]=16L;
data[11]=17592186044416L;
data[34]=1024L;
return data;
}
public static final BitSet _tokenSet_211 = new BitSet(mk_tokenSet_211());
private static final long[] mk_tokenSet_212() {
long[] data = new long[94];
data[0]=16L;
data[8]=16777216L;
data[11]=17592186044417L;
data[14]=2048L;
data[16]=576460752303423488L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_212 = new BitSet(mk_tokenSet_212());
private static final long[] mk_tokenSet_213() {
long[] data = new long[48];
data[0]=16L;
data[11]=17592186044417L;
data[16]=576460752303423488L;
return data;
}
public static final BitSet _tokenSet_213 = new BitSet(mk_tokenSet_213());
private static final long[] mk_tokenSet_214() {
long[] data = new long[94];
data[0]=16L;
data[8]=281474993487872L;
data[11]=580542139465728L;
data[13]=131072L;
data[16]=33554432L;
data[18]=134217728L;
data[21]=562949953421312L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_214 = new BitSet(mk_tokenSet_214());
private static final long[] mk_tokenSet_215() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790154977280L;
return data;
}
public static final BitSet _tokenSet_215 = new BitSet(mk_tokenSet_215());
private static final long[] mk_tokenSet_216() {
long[] data = new long[94];
data[0]=16L;
data[14]=2048L;
data[46]=134217728L;
return data;
}
public static final BitSet _tokenSet_216 = new BitSet(mk_tokenSet_216());
private static final long[] mk_tokenSet_217() {
long[] data = new long[120];
data[0]=16L;
data[7]=35184271425280L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592320262144L;
return data;
}
public static final BitSet _tokenSet_217 = new BitSet(mk_tokenSet_217());
private static final long[] mk_tokenSet_218() {
long[] data = new long[48];
data[0]=16L;
data[11]=17592186044416L;
data[14]=16L;
return data;
}
public static final BitSet _tokenSet_218 = new BitSet(mk_tokenSet_218());
private static final long[] mk_tokenSet_219() {
long[] data = new long[48];
data[15]=137438953472L;
return data;
}
public static final BitSet _tokenSet_219 = new BitSet(mk_tokenSet_219());
private static final long[] mk_tokenSet_220() {
long[] data = new long[78];
data[38]=36028797018963968L;
return data;
}
public static final BitSet _tokenSet_220 = new BitSet(mk_tokenSet_220());
private static final long[] mk_tokenSet_221() {
long[] data = new long[90];
data[0]=16L;
data[11]=1L;
data[14]=4194336L;
data[15]=35184908959744L;
data[19]=72057594037927968L;
data[22]=8589934624L;
data[25]=35184372088832L;
data[26]=2199023255552L;
data[28]=1024L;
data[29]=2147483648L;
data[30]=144L;
data[31]=1024L;
data[32]=70368744177664L;
data[34]=2147483648L;
data[35]=16L;
data[39]=16777216L;
data[44]=8L;
return data;
}
public static final BitSet _tokenSet_221 = new BitSet(mk_tokenSet_221());
private static final long[] mk_tokenSet_222() {
long[] data = new long[60];
data[0]=16L;
data[11]=1L;
data[14]=4194304L;
data[15]=536870912L;
data[22]=8589934592L;
data[28]=1024L;
data[29]=2147483648L;
return data;
}
public static final BitSet _tokenSet_222 = new BitSet(mk_tokenSet_222());
private static final long[] mk_tokenSet_223() {
long[] data = new long[90];
data[0]=16L;
data[11]=1L;
data[14]=4194336L;
data[15]=35184372088832L;
data[19]=72057594037927968L;
data[22]=32L;
data[25]=35184372088832L;
data[30]=144L;
data[34]=2147483648L;
data[35]=16L;
data[39]=16777216L;
data[44]=8L;
return data;
}
public static final BitSet _tokenSet_223 = new BitSet(mk_tokenSet_223());
private static final long[] mk_tokenSet_224() {
long[] data = new long[90];
data[0]=16L;
data[11]=1L;
data[13]=8796093022208L;
data[14]=2151677984L;
data[15]=35184372088832L;
data[19]=72057594037927968L;
data[22]=32L;
data[25]=35184372088832L;
data[30]=144L;
data[34]=2147483648L;
data[35]=16L;
data[39]=16777216L;
data[44]=24L;
return data;
}
public static final BitSet _tokenSet_224 = new BitSet(mk_tokenSet_224());
private static final long[] mk_tokenSet_225() {
long[] data = new long[90];
data[0]=16L;
data[11]=1L;
data[14]=4194336L;
data[15]=35184372088832L;
data[19]=72057594037927968L;
data[22]=32L;
data[25]=35184372088832L;
data[30]=144L;
data[34]=2147483648L;
data[35]=16L;
data[39]=16777216L;
data[44]=24L;
return data;
}
public static final BitSet _tokenSet_225 = new BitSet(mk_tokenSet_225());
private static final long[] mk_tokenSet_226() {
long[] data = new long[66];
data[0]=16L;
data[11]=1L;
data[14]=4194304L;
data[26]=2199023255552L;
data[31]=1024L;
data[32]=70368744177664L;
return data;
}
public static final BitSet _tokenSet_226 = new BitSet(mk_tokenSet_226());
private static final long[] mk_tokenSet_227() {
long[] data = new long[94];
data[0]=16L;
data[11]=1L;
data[14]=4194336L;
data[15]=35184372088832L;
data[19]=72057594037927968L;
data[22]=32L;
data[25]=105553116266496L;
data[30]=144L;
data[34]=2147483648L;
data[35]=16L;
data[39]=16777216L;
data[44]=24L;
data[46]=268435456L;
return data;
}
public static final BitSet _tokenSet_227 = new BitSet(mk_tokenSet_227());
private static final long[] mk_tokenSet_228() {
long[] data = new long[74];
data[10]=576460752303423488L;
data[12]=4503599627370496L;
data[15]=134217728L;
data[18]=347925905408L;
data[22]=1099511693312L;
data[24]=36028797018963968L;
data[26]=4294967296L;
data[30]=32L;
data[32]=140737496743936L;
data[36]=4194304L;
return data;
}
public static final BitSet _tokenSet_228 = new BitSet(mk_tokenSet_228());
private static final long[] mk_tokenSet_229() {
long[] data = new long[82];
data[40]=4503599627370496L;
return data;
}
public static final BitSet _tokenSet_229 = new BitSet(mk_tokenSet_229());
private static final long[] mk_tokenSet_230() {
long[] data = new long[82];
data[40]=16L;
return data;
}
public static final BitSet _tokenSet_230 = new BitSet(mk_tokenSet_230());
private static final long[] mk_tokenSet_231() {
long[] data = new long[50];
data[24]=9007199254740992L;
return data;
}
public static final BitSet _tokenSet_231 = new BitSet(mk_tokenSet_231());
private static final long[] mk_tokenSet_232() {
long[] data = new long[94];
data[8]=648799821322256384L;
data[9]=134217728L;
data[10]=576460752308142080L;
data[11]=576460752370794496L;
data[14]=72057596185411584L;
data[16]=8388608L;
data[18]=34359933952L;
data[19]=549755813888L;
data[21]=20266198323167232L;
data[25]=4398046511104L;
data[26]=532575944704L;
data[27]=9007199254740992L;
data[29]=2251799813685248L;
data[32]=34359738368L;
data[34]=562949953421312L;
data[35]=3458764513820540928L;
data[38]=-9223372036854775808L;
data[40]=1786706395138L;
data[46]=35184372088832L;
return data;
}
public static final BitSet _tokenSet_232 = new BitSet(mk_tokenSet_232());
private static final long[] mk_tokenSet_233() {
long[] data = new long[120];
data[8]=4194304L;
data[11]=128L;
data[14]=-1125899906777088L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_233 = new BitSet(mk_tokenSet_233());
private static final long[] mk_tokenSet_234() {
long[] data = new long[48];
data[0]=16L;
data[8]=288230377225453568L;
data[10]=2251799813685248L;
data[11]=17592186077184L;
data[12]=67108864L;
data[14]=4398046511104L;
return data;
}
public static final BitSet _tokenSet_234 = new BitSet(mk_tokenSet_234());
private static final long[] mk_tokenSet_235() {
long[] data = new long[120];
data[0]=336L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=23L;
data[8]=1495195077763412208L;
data[9]=2319776022742044000L;
data[10]=6765037339541636L;
data[11]=-3458746645545451264L;
data[12]=18382030601978112L;
data[13]=-6232975008038092672L;
data[14]=-1121501843553764L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_235 = new BitSet(mk_tokenSet_235());
private static final long[] mk_tokenSet_236() {
long[] data = new long[94];
data[0]=16L;
data[10]=1125899906842624L;
data[46]=536870912L;
return data;
}
public static final BitSet _tokenSet_236 = new BitSet(mk_tokenSet_236());
private static final long[] mk_tokenSet_237() {
long[] data = new long[120];
data[0]=336L;
data[2]=545259520L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30790356303872L;
return data;
}
public static final BitSet _tokenSet_237 = new BitSet(mk_tokenSet_237());
private static final long[] mk_tokenSet_238() {
long[] data = new long[48];
data[0]=16L;
data[11]=1L;
data[13]=8796093022208L;
data[14]=2151677952L;
return data;
}
public static final BitSet _tokenSet_238 = new BitSet(mk_tokenSet_238());
private static final long[] mk_tokenSet_239() {
long[] data = new long[48];
data[0]=16L;
data[11]=1L;
data[13]=8796093022208L;
data[14]=2151677984L;
return data;
}
public static final BitSet _tokenSet_239 = new BitSet(mk_tokenSet_239());
private static final long[] mk_tokenSet_240() {
long[] data = new long[94];
data[8]=4194304L;
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_240 = new BitSet(mk_tokenSet_240());
private static final long[] mk_tokenSet_241() {
long[] data = new long[120];
data[0]=129344L;
data[2]=536870912L;
data[3]=4178112L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=65974728392704L;
return data;
}
public static final BitSet _tokenSet_241 = new BitSet(mk_tokenSet_241());
private static final long[] mk_tokenSet_242() {
long[] data = new long[120];
data[10]=1048576L;
data[11]=262144L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17593528221696L;
return data;
}
public static final BitSet _tokenSet_242 = new BitSet(mk_tokenSet_242());
private static final long[] mk_tokenSet_243() {
long[] data = new long[120];
data[0]=320L;
data[3]=49280L;
data[8]=-8L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17595675705344L;
return data;
}
public static final BitSet _tokenSet_243 = new BitSet(mk_tokenSet_243());
private static final long[] mk_tokenSet_244() {
long[] data = new long[94];
data[0]=16L;
data[11]=17592186044416L;
data[14]=34359738368L;
data[46]=536870912L;
return data;
}
public static final BitSet _tokenSet_244 = new BitSet(mk_tokenSet_244());
private static final long[] mk_tokenSet_245() {
long[] data = new long[94];
data[8]=171798691840L;
data[11]=576460752370532481L;
data[18]=137438953472L;
data[21]=17179869184L;
data[24]=211106232532992L;
data[27]=4615063718147915776L;
data[30]=8192L;
data[46]=494230493462528L;
return data;
}
public static final BitSet _tokenSet_245 = new BitSet(mk_tokenSet_245());
private static final long[] mk_tokenSet_246() {
long[] data = new long[48];
data[8]=137438953472L;
data[11]=576460752370532481L;
return data;
}
public static final BitSet _tokenSet_246 = new BitSet(mk_tokenSet_246());
private static final long[] mk_tokenSet_247() {
long[] data = new long[94];
data[8]=1081344L;
data[10]=2L;
data[11]=576460752303423488L;
data[13]=4503599627370496L;
data[46]=536870912L;
return data;
}
public static final BitSet _tokenSet_247 = new BitSet(mk_tokenSet_247());
private static final long[] mk_tokenSet_248() {
long[] data = new long[78];
data[16]=16L;
data[18]=2251799813685248L;
data[27]=-9223372036854775808L;
data[29]=16777216L;
data[38]=4L;
return data;
}
public static final BitSet _tokenSet_248 = new BitSet(mk_tokenSet_248());
private static final long[] mk_tokenSet_249() {
long[] data = new long[48];
data[10]=5452595200L;
return data;
}
public static final BitSet _tokenSet_249 = new BitSet(mk_tokenSet_249());
private static final long[] mk_tokenSet_250() {
long[] data = new long[70];
data[8]=2147614720L;
data[9]=16L;
data[11]=550292684808L;
data[12]=288230376151711744L;
data[19]=536870912L;
data[21]=134217728L;
data[33]=-9214364837600034816L;
data[34]=5764607523034234880L;
return data;
}
public static final BitSet _tokenSet_250 = new BitSet(mk_tokenSet_250());
private static final long[] mk_tokenSet_251() {
long[] data = new long[120];
data[0]=129344L;
data[2]=536870912L;
data[3]=4177920L;
data[5]=1152912708513824768L;
data[6]=-387028579778561L;
data[7]=-281474976710633L;
data[8]=-5L;
for (int i = 9; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=30789014126592L;
return data;
}
public static final BitSet _tokenSet_251 = new BitSet(mk_tokenSet_251());
private static final long[] mk_tokenSet_252() {
long[] data = new long[120];
data[0]=320L;
data[7]=-281474976710656L;
data[8]=3L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_252 = new BitSet(mk_tokenSet_252());
private static final long[] mk_tokenSet_253() {
long[] data = new long[120];
data[5]=1152912708513824768L;
data[8]=-6914679093501868000L;
data[9]=1454099729695473664L;
data[10]=72088385816297732L;
data[11]=19508328962L;
data[12]=10142032831971329L;
data[13]=35338990911488L;
data[14]=-1125899890061056L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592190238720L;
return data;
}
public static final BitSet _tokenSet_253 = new BitSet(mk_tokenSet_253());
private static final long[] mk_tokenSet_254() {
long[] data = new long[120];
data[0]=320L;
data[2]=536870912L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_254 = new BitSet(mk_tokenSet_254());
private static final long[] mk_tokenSet_255() {
long[] data = new long[120];
data[0]=129088L;
data[9]=8L;
data[10]=65536L;
data[11]=1099512152064L;
data[14]=-1125899906842624L;
for (int i = 15; i<=44; i++) { data[i]=-1L; }
data[45]=140737488355327L;
data[46]=17592186044416L;
return data;
}
public static final BitSet _tokenSet_255 = new BitSet(mk_tokenSet_255());
private static final long[] mk_tokenSet_256() {
long[] data = new long[94];
data[3]=4177920L;
data[8]=4294967296L;
data[9]=4398046511104L;
data[10]=2305844246164339785L;
data[11]=307388266754211840L;
data[12]=108086399646826498L;
data[13]=88064546076672L;
data[14]=4157570285568L;
data[26]=72057594037927936L;
data[31]=4611686018427387904L;
data[38]=1048576L;
data[46]=13197360758784L;
return data;
}
public static final BitSet _tokenSet_256 = new BitSet(mk_tokenSet_256());
private static final long[] mk_tokenSet_257() {
long[] data = new long[94];
data[46]=536870912L;
return data;
}
public static final BitSet _tokenSet_257 = new BitSet(mk_tokenSet_257());
private static final long[] mk_tokenSet_258() {
long[] data = new long[94];
data[11]=1L;
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_258 = new BitSet(mk_tokenSet_258());
private static final long[] mk_tokenSet_259() {
long[] data = new long[94];
data[17]=144L;
data[46]=1342177280L;
return data;
}
public static final BitSet _tokenSet_259 = new BitSet(mk_tokenSet_259());
private static final long[] mk_tokenSet_260() {
long[] data = new long[94];
data[46]=67108864L;
return data;
}
public static final BitSet _tokenSet_260 = new BitSet(mk_tokenSet_260());
}