ASParser (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- antlr.Parser
- - antlr.LLkParser
  - - org.apache.flex.compiler.internal.parsing.as.ASParser

All Implemented Interfaces:

ASTokenTypes, IProblemReporter
```
public class ASParser
extends antlr.LLkParser
implements ASTokenTypes
```
ActionScript3 parser grammar. It consumes ASTokens and produces IASNode AST. The number of tokens in a single syntactic predicate can not be greater than StreamingTokenBuffer.REWIND_BUFFER_SIZE.

See Also:
ActionScript Language Syntax Specification

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class BaseASParser.ExpressionMode

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`BaseASParser.ExpressionMode`

Field Summary

Fields
Modifier and Type	Field and Description
`static String[]`	`_tokenNames`
`static antlr.collections.impl.BitSet`	`_tokenSet_0`
`static antlr.collections.impl.BitSet`	`_tokenSet_1`
`static antlr.collections.impl.BitSet`	`_tokenSet_10`
`static antlr.collections.impl.BitSet`	`_tokenSet_11`
`static antlr.collections.impl.BitSet`	`_tokenSet_12`
`static antlr.collections.impl.BitSet`	`_tokenSet_13`
`static antlr.collections.impl.BitSet`	`_tokenSet_14`
`static antlr.collections.impl.BitSet`	`_tokenSet_15`
`static antlr.collections.impl.BitSet`	`_tokenSet_16`
`static antlr.collections.impl.BitSet`	`_tokenSet_17`
`static antlr.collections.impl.BitSet`	`_tokenSet_18`
`static antlr.collections.impl.BitSet`	`_tokenSet_19`
`static antlr.collections.impl.BitSet`	`_tokenSet_2`
`static antlr.collections.impl.BitSet`	`_tokenSet_3`
`static antlr.collections.impl.BitSet`	`_tokenSet_4`
`static antlr.collections.impl.BitSet`	`_tokenSet_5`
`static antlr.collections.impl.BitSet`	`_tokenSet_6`
`static antlr.collections.impl.BitSet`	`_tokenSet_7`
`static antlr.collections.impl.BitSet`	`_tokenSet_8`
`static antlr.collections.impl.BitSet`	`_tokenSet_9`
`protected boolean`	`allowEmbeds` Flag to determine if we should create EmbedNodes or ignore embed metadata
`protected IASParserASDocDelegate`	`asDocDelegate` `IASParserASDocDelegate` used to track ASDoc information.
`protected IRepairingTokenBuffer`	`buffer` Our version of a token buffer that allows us to handle optional semicolons, etc
`protected MetaTagsNode`	`currentAttributes` Current metadata attributes.
`protected DeferFunctionBody`	`deferFunctionBody` True if the current input source is an ActionScript file, as opposed to AS3 scripts in MXML or other synthesized source fragments.
`static IProjectConfigVariables`	`EMPTY_CONFIGURATION` Variable to use as an empty project configuration
`protected Set<ICompilerProblem>`	`errors` Errors we've collected as we're moving forward
`protected antlr.Token`	`errorToken` Last token that produced an error
`protected BaseASParser.ExpressionMode`	`expressionMode` Expression mode of the current parsing state.
`protected boolean`	`insideClass` flag that tracks whether the parser is currently inside of a class definition this is "borrowed" from the old parser to deal with some ASDoc functionality
`protected static int`	`NO_END_TOKEN` Used to specify "directive" rule's end token as "no end token" - the parser will consume till the end of the input stream when recover from errors.

Fields inherited from class antlr.Parser
astFactory, inputState, returnAST, tokenNames, tokenTypeToASTClassMap, traceDepth

Fields inherited from interface org.apache.flex.compiler.internal.parsing.as.ASTokenTypes
EOF, HIDDEN_TOKEN_BUILTIN_NS, HIDDEN_TOKEN_COMMENT, HIDDEN_TOKEN_E4X, HIDDEN_TOKEN_MULTI_LINE_COMMENT, HIDDEN_TOKEN_SINGLE_LINE_COMMENT, HIDDEN_TOKEN_STAR_ASSIGNMENT, NULL_TREE_LOOKAHEAD, TOKEN_ASDOC_COMMENT, TOKEN_ASDOC_TAG, TOKEN_ASDOC_TEXT, TOKEN_ATTRIBUTE, TOKEN_BLOCK_CLOSE, TOKEN_BLOCK_OPEN, TOKEN_COLON, TOKEN_COMMA, TOKEN_DIRECTIVE_DEFAULT_XML, TOKEN_E4X_BINDING_CLOSE, TOKEN_E4X_BINDING_OPEN, TOKEN_E4X_CDATA, TOKEN_E4X_CLOSE_TAG_START, TOKEN_E4X_COMMENT, TOKEN_E4X_DECIMAL_ENTITY, TOKEN_E4X_DOTTED_NAME_PART, TOKEN_E4X_EMPTY_TAG_END, TOKEN_E4X_ENTITY, TOKEN_E4X_EQUALS, TOKEN_E4X_HEX_ENTITY, TOKEN_E4X_NAME, TOKEN_E4X_NAME_DOT, TOKEN_E4X_OPEN_TAG_START, TOKEN_E4X_PROCESSING_INSTRUCTION, TOKEN_E4X_STRING, TOKEN_E4X_TAG_END, TOKEN_E4X_TEXT, TOKEN_E4X_WHITESPACE, TOKEN_E4X_XMLLIST_CLOSE, TOKEN_E4X_XMLNS, TOKEN_ELLIPSIS, TOKEN_IDENTIFIER, TOKEN_KEYWORD_AS, TOKEN_KEYWORD_BREAK, TOKEN_KEYWORD_CASE, TOKEN_KEYWORD_CATCH, TOKEN_KEYWORD_CLASS, TOKEN_KEYWORD_CONST, TOKEN_KEYWORD_CONTINUE, TOKEN_KEYWORD_DEFAULT, TOKEN_KEYWORD_DELETE, TOKEN_KEYWORD_DO, TOKEN_KEYWORD_ELSE, TOKEN_KEYWORD_FALSE, TOKEN_KEYWORD_FINALLY, TOKEN_KEYWORD_FOR, TOKEN_KEYWORD_FUNCTION, TOKEN_KEYWORD_IF, TOKEN_KEYWORD_IMPORT, TOKEN_KEYWORD_IN, TOKEN_KEYWORD_INCLUDE, TOKEN_KEYWORD_INSTANCEOF, TOKEN_KEYWORD_INTERFACE, TOKEN_KEYWORD_IS, TOKEN_KEYWORD_NEW, TOKEN_KEYWORD_NULL, TOKEN_KEYWORD_PACKAGE, TOKEN_KEYWORD_RETURN, TOKEN_KEYWORD_SUPER, TOKEN_KEYWORD_SWITCH, TOKEN_KEYWORD_THIS, TOKEN_KEYWORD_THROW, TOKEN_KEYWORD_TRUE, TOKEN_KEYWORD_TRY, TOKEN_KEYWORD_TYPEOF, TOKEN_KEYWORD_USE, TOKEN_KEYWORD_VAR, TOKEN_KEYWORD_VOID, TOKEN_KEYWORD_WHILE, TOKEN_KEYWORD_WITH, TOKEN_LITERAL_HEX_NUMBER, TOKEN_LITERAL_NUMBER, TOKEN_LITERAL_REGEXP, TOKEN_LITERAL_STRING, TOKEN_LITERAL_XMLLIST, TOKEN_MODIFIER_DYNAMIC, TOKEN_MODIFIER_FINAL, TOKEN_MODIFIER_NATIVE, TOKEN_MODIFIER_OVERRIDE, TOKEN_MODIFIER_STATIC, TOKEN_MODIFIER_VIRTUAL, TOKEN_NAMESPACE_ANNOTATION, TOKEN_NAMESPACE_NAME, TOKEN_OPERATOR_ASSIGNMENT, TOKEN_OPERATOR_ATSIGN, TOKEN_OPERATOR_BITWISE_AND, TOKEN_OPERATOR_BITWISE_AND_ASSIGNMENT, TOKEN_OPERATOR_BITWISE_LEFT_SHIFT, TOKEN_OPERATOR_BITWISE_LEFT_SHIFT_ASSIGNMENT, TOKEN_OPERATOR_BITWISE_NOT, TOKEN_OPERATOR_BITWISE_OR, TOKEN_OPERATOR_BITWISE_OR_ASSIGNMENT, TOKEN_OPERATOR_BITWISE_RIGHT_SHIFT, TOKEN_OPERATOR_BITWISE_RIGHT_SHIFT_ASSIGNMENT, TOKEN_OPERATOR_BITWISE_UNSIGNED_RIGHT_SHIFT, TOKEN_OPERATOR_BITWISE_UNSIGNED_RIGHT_SHIFT_ASSIGNMENT, TOKEN_OPERATOR_BITWISE_XOR, TOKEN_OPERATOR_BITWISE_XOR_ASSIGNMENT, TOKEN_OPERATOR_DECREMENT, TOKEN_OPERATOR_DESCENDANT_ACCESS, TOKEN_OPERATOR_DIVISION, TOKEN_OPERATOR_DIVISION_ASSIGNMENT, TOKEN_OPERATOR_EQUAL, TOKEN_OPERATOR_GREATER_THAN, TOKEN_OPERATOR_GREATER_THAN_EQUALS, TOKEN_OPERATOR_INCREMENT, TOKEN_OPERATOR_LESS_THAN, TOKEN_OPERATOR_LESS_THAN_EQUALS, TOKEN_OPERATOR_LOGICAL_AND, TOKEN_OPERATOR_LOGICAL_AND_ASSIGNMENT, TOKEN_OPERATOR_LOGICAL_NOT, TOKEN_OPERATOR_LOGICAL_OR, TOKEN_OPERATOR_LOGICAL_OR_ASSIGNMENT, TOKEN_OPERATOR_MEMBER_ACCESS, TOKEN_OPERATOR_MINUS, TOKEN_OPERATOR_MINUS_ASSIGNMENT, TOKEN_OPERATOR_MODULO, TOKEN_OPERATOR_MODULO_ASSIGNMENT, TOKEN_OPERATOR_MULTIPLICATION_ASSIGNMENT, TOKEN_OPERATOR_NOT_EQUAL, TOKEN_OPERATOR_NS_QUALIFIER, TOKEN_OPERATOR_PLUS, TOKEN_OPERATOR_PLUS_ASSIGNMENT, TOKEN_OPERATOR_STAR, TOKEN_OPERATOR_STRICT_EQUAL, TOKEN_OPERATOR_STRICT_NOT_EQUAL, TOKEN_OPERATOR_TERNARY, TOKEN_PAREN_CLOSE, TOKEN_PAREN_OPEN, TOKEN_RESERVED_WORD_CONFIG, TOKEN_RESERVED_WORD_EACH, TOKEN_RESERVED_WORD_EXTENDS, TOKEN_RESERVED_WORD_GET, TOKEN_RESERVED_WORD_GOTO, TOKEN_RESERVED_WORD_IMPLEMENTS, TOKEN_RESERVED_WORD_NAMESPACE, TOKEN_RESERVED_WORD_SET, TOKEN_SEMICOLON, TOKEN_SQUARE_CLOSE, TOKEN_SQUARE_OPEN, TOKEN_TYPED_COLLECTION_CLOSE, TOKEN_TYPED_COLLECTION_OPEN, TOKEN_TYPED_LITERAL_CLOSE, TOKEN_TYPED_LITERAL_OPEN, TOKEN_VOID_0

Constructor Summary

Constructors
Modifier	Constructor and Description
	`ASParser(IWorkspace workspace, IRepairingTokenBuffer buffer)` Construct an AS3 parser from a token buffer.
	`ASParser(IWorkspace workspace, IRepairingTokenBuffer buffer, boolean parsingProjectConfigVariables)` Construct an AS3 parser for parsing command line config args
	`ASParser(antlr.ParserSharedInputState state)`
	`ASParser(antlr.TokenBuffer tokenBuf)`
`protected`	`ASParser(antlr.TokenBuffer tokenBuf, int k)`
	`ASParser(antlr.TokenStream lexer)`
`protected`	`ASParser(antlr.TokenStream lexer, int k)`

Method Summary

Methods
Modifier and Type	Method and Description
`ExpressionNodeBase`	`accessPart()` Matches parts after the dot in a property access expression.
`protected void`	`addConditionalCompilationNamespace(NamespaceNode node)`
`void`	`addProblem(ICompilerProblem problem)` Adds an `ICompilerProblem` to this reporter
`protected void`	`afterInnerSubstatement()` Ignore missing semicolons in the following two cases: do x++ while (x<10); // after x++ if (x<10) x++ else x--; // after x++
`protected boolean`	`afterRestrictedToken(ASToken current)` Call this method in the grammar once a "restricted token" is matched.
`void`	`argumentList(ContainerNode args)` Matches an argument list in a function call arguments.
`ExpressionNodeBase`	`arguments(ExpressionNodeBase root)` Matches the arguments of a function call: allcharacters between (...)
`ExpressionNodeBase`	`arrayElement()` Matches an "array element" in an "array literal".
`void`	`arrayElements(ContainerNode b)` Matches all the elements in an "arrayInitializer".
`void`	`arrayInitializer(ArrayLiteralNode node)` Matches array literal.
`void`	`asDocComment()` Matches an ASDoc block.
`ExpressionNodeBase`	`assignmentExpression()` Matches an "assignment expression".
`ExpressionNodeBase`	`assignmentRightValue()` Matches the right-hand side of an assignment expression.
`ASToken`	`assignOp()`
`void`	`attribute(List<ModifierNode> modifiers, List<INamespaceDecorationNode> namespaceAttributes)` Matches an attribute such as: - Modifiers: dynamic, final, native, override, static, virtual
`void`	`attributedDefinition(ContainerNode c)` Matches an attributed definition.
`protected boolean`	`beforeRestrictedToken(ASToken nextToken)` See Javadoc for `afterRestrictedToken(ASToken)` for details about "restricted token" and semicolon insertion.
`ExpressionNodeBase`	`binaryExpr()` Binary expression uses operator precedence parser in BaseASParser.
`void`	`binaryOperators()` Declares all the binary operators.
`void`	`block(ContainerNode b)` Matches a block.
`DynamicAccessNode`	`bracketExpression(ExpressionNodeBase root)` Matches a bracket expression.
`void`	`breakOrContinueStatement(ContainerNode c)` Matches a "break statement" or a "continue statement".
`void`	`caseClause(ContainerNode swb)` Matches a single "case" clause in a "switch" statement.
`void`	`caseClauses(ContainerNode swb)` Matches the "case" clauses in a "switch" statement.
`void`	`cases(SwitchNode sw)` Matches the "case" block in a "switch" statement.
`void`	`caseStatementList(ContainerNode b)` Matches the statements in a "case" clause.
`void`	`catchBlock(TryNode tryNode)` Matches the "catch" block in a "try" statement.
`ParameterNode`	`catchBlockArgument()` Matches the argument in the "try...catch(arg)" statement.
`ChainedVariableNode`	`chainedVariable(ContainerNode c)` Matches a chained variable/constant definition.
`protected void`	`checkForChainedNamespaceQualifierProblem(ASToken nsAccessOp, ExpressionNodeBase right)` Check for syntax error of chained namespace qualifiers: ns1::ns2::ns3::foo = 10;
`protected void`	`checkNamespaceDefinition(NamespaceNode ns)` Check if the namespace conflicts with a config namespace
`void`	`classDefinition(ContainerNode c, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Matches a class definition.
`void`	`classOrInterfaceBlock(BlockNode b)` Matches the content block of a class definition or an interface definition.
`void`	`colon()` Matches a colon token ":" or recover from a missing colon.
`ExpressionNodeBase`	`condExpr()` Matches a ternary expression such as: (x > 2) ?
`boolean`	`configCondition()` Matches a config condition such as "CONFIG::debug".
`boolean`	`configConditionOfDefinition()` Similar to "configCondition", only that the token type after "::" is "TOKEN_NAMESPACE_ANNOTATION".
`void`	`configNamespace(ContainerNode c)` Matches a "config namespace foo" directive.
`void`	`consume()`
`protected void`	`consumeParsingError(antlr.RecognitionException ex)`
`protected void`	`consumeParsingError(antlr.RecognitionException ex, int endToken)` Create a syntax error or warning based on the `RecognitionException`.
`protected void`	`consumeUntilKeywordOr(Integer... types)` Consume until a keyword, EOF or specified token types.
`protected void`	`consumeUntilKeywordOrIdentifier(int exitCondition)` Consume until one of the following tokens: keyword identifier EOF metadata tag ASDoc comment token type of the given exit condition
`void`	`defaultXMLNamespaceStatement(ContainerNode c)` Matches a default XML namespace statement.
`void`	`definition(ContainerNode c, INamespaceDecorationNode ns, List<ModifierNode> modList)` Matches a definition of variable, function, namespace, class or interface.
`void`	`directive(ContainerNode c, int endToken)` Matches a "directive" level input.
`protected void`	`disableSemicolonInsertion()`
`protected void`	`disconnect()` Close the parser and release resources.
`void`	`doStatement(ContainerNode c)` Matches a "do...while" statement.
`boolean`	`elsePart(IfNode i)` Matches the optional "else" block of an "if" statement.
`void`	`emptyStatement()` Matches an empty statement which is an explicit semicolon.
`protected void`	`enableSemicolonInsertion()`
`protected void`	`encounteredImport(ImportNode importNode)`
`protected void`	`endContainerAtError(antlr.RecognitionException ex, NodeBase node)`
`protected void`	`enterClassDefinition(ASToken keywordClass)` Check if class definition is allowed.
`protected void`	`enterGroup()` Enter a "group" and increment the depth counter.
`protected void`	`enterInterfaceDefinition(ASToken keywordInterface)` Check if interface definition is allowed.
`protected void`	`enterPackage(ASToken keywordPackage)` Increment package depth counter and check for `NestedPackageProblem`.
`protected void`	`enterTypeApplication(ExpressionNodeBase collectionExpression)` Called when the parser enters a type application expression.
`protected void`	`enterXMLLiteral()` Called when start parsing an XML literal.
`protected boolean`	`evaluateConfigurationVariable(IdentifierNode configNamespace, ASToken opToken, IdentifierNode configVar)` Evaluate configuration variable result.
`protected LiteralNode`	`evaluateConstNodeExpression(ConfigExpressionNode node)`
`protected IdentifierNode`	`expectingIdentifier(antlr.NoViableAltException ex)` Force the parser to report a `MismatchedTokenException` when failed to parse an identifier.
`ExpressionNodeBase`	`expression()` Matches an expression or a comma-separated expression list.
`void`	`expressionStatement(ContainerNode c)` Matches an "expression statement".
`void`	`fakeExpr()` fakeExpr simulates the set of allowable follow tokens in an expression context, which allows antlr to function.
`void`	`file(ContainerNode c)` Parses an ActionScript3 file and populate the FileNode.
`void`	`fileLevelDirectives(ContainerNode c)` Matches multiple directives.
`void`	`forCondition(ContainerNode c)` Matches the "condition" part in a for loop.
`NodeBase`	`forInitializer()` Matches the "initializer" part in a for loop.
`void`	`formal(ContainerNode c)` Matches a single parameter in a function definition.
`void`	`formalParameters(ContainerNode c)` Matches the parameters of a function definition signature (excluding the parenthesis).
`void`	`forStatement(ContainerNode c)` Matches a "for loop" statement.
`void`	`forStep(ContainerNode c)` Matches the "step" part in a for loop.
`protected void`	`foundExtraCharacterAfterEndOfProgram(ASToken token)` Call this method when extra characters were found after the end of the program.
`void`	`functionBlock(FunctionNode f, ASToken openT)` Matches a function block, excluding the open "{" but including the closing "}".
`void`	`functionDefinition(ContainerNode c, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Matches a function definition.
`FunctionObjectNode`	`functionExpression()` Matches an anonymous function (function closure).
`String`	`getSourceFilePath()` Gets the source file that we are reporting for
`Collection<ICompilerProblem>`	`getSyntaxProblems()`
`void`	`gotoStatement(ContainerNode c)` Matches a "goto" statement.
`void`	`groupDirective(ContainerNode c, int endToken)` Matches a "group" in a "group directive".
`void`	`groupDirectiveWithConfigVariable(ContainerNode c, int endToken)` Matches a group of directives gated with configuration variable.
`protected IdentifierNode`	`handleMissingIdentifier(antlr.RecognitionException ex)` handles a case where we expected an identifier but our production produced an error, while we were trying to produce a short name.
`protected ExpressionNodeBase`	`handleMissingIdentifier(antlr.RecognitionException ex, ExpressionNodeBase n)` handles a case where we expected an identifier but our production produced an error, while we were trying to produce a dotted name.
`protected boolean`	`handleParsingError(antlr.RecognitionException ex)`
`protected boolean`	`handleParsingError(antlr.RecognitionException ex, int endToken)` Called by the parser to handle specific error cases we come across.
`IdentifierNode`	`identifier()` Matches an identifier token.
`void`	`ifStatement(ContainerNode c)` Matches an "if" statement.
`void`	`importDirective(ContainerNode c)` Matches an import directive.
`ExpressionNodeBase`	`importName()` Matches an "import-able" name.
`void`	`includeDirective()` Include processing is usually done in the lexer.
`void`	`initializer(IInitializableDefinitionNode v)` Matches an initializer in a variable/constant definition.
`void`	`innerSubstatement(ContainerNode c)` From ASL syntax spec: InnerSubstatement is defined in the grammar for the sole purpose of specifying side conditions that disambiguate various syntactic ambiguities in a context-sensitive manner specified in Section 5.
`void`	`interfaceDefinition(ContainerNode c, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Matches an interface definition.
`protected boolean`	`isConfigCondition()` Check if the look-ahead can be matched as a "ConfigCondition".
`protected boolean`	`isConfigNamespace(NamespaceIdentifierNode id)`
`protected boolean`	`isDefinitionEnabled(ContainerNode containerNode)` Check if the next attribute definition is gated with a configuration condition variable.
`protected boolean`	`isFunctionClosure()` Disambiguate between a function definition and a function closure.
`protected boolean`	`isGlobalContext()` A syntax tree is in a global context if it is nested by a program without crossing a block, or nested by the block of a package directive without crossing another block.
`protected boolean`	`isIncompleteMetadataTagOnDefinition()` Determine if the parser should deploy an error trap for a typing-in-progress metadata tag on a definition item.
`protected boolean`	`isNextTokenPublicNamespace()` Syntactic predicate for CMP-335.
`boolean`	`isParsingProjectConfigVariables()`
`protected boolean`	`isXMLAttribute()` Check if the look-ahead can be matched as a "XMLAttribute".
`int`	`LA(int i)`
`void`	`labeledStatement(ContainerNode c, int exitCondition)` Matches a "labeled statement".
`protected void`	`leaveGroup()` Leave a "group" and decrement the depth counter.
`protected void`	`leavePackage()` Decrement package depth counter.
`protected void`	`leaveXMLLiteral()` Called when finish parsing an XML literal.
`ExpressionNodeBase`	`lhsExpr()` Matches a left-hand side (of asssignment) expression.
`protected void`	`logMultipleConfigNamespaceDecorationsError(NodeBase source)`
`protected void`	`logSyntaxError(ASToken badToken)` Logs a syntax error against the given token
`ASToken`	`LT(int i)`
`int`	`mark()`
`void`	`match(int t)`
`protected boolean`	`matchOptionalSemicolon()` Match optional semicolon.
`ExpressionNodeBase`	`memberExpression()` Matches a member expression.
`void`	`meta(ContainerNode c)` Matches a "metadata statement".
`ModifierNode`	`modifierAttribute()` Matches a "modifier attribute" such as "final", "dynamic", "override", "static" or "native".
`ExpressionNodeBase`	`nameExpression()` This is a non-greedy and non-aggregating version of "restricted name".
`void`	`namespaceDefinition(ContainerNode c, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Matches a namespace definition.
`protected boolean`	`namespaceIsConfigNamespace(INamespaceDecorationNode node)`
`ExpressionNodeBase`	`namespaceModifier()` Matches a namespace modifier on an "attributed definition".
`ExpressionNodeBase`	`newExpression()` Matches a new expression.
`ExpressionNodeBase`	`nsAccessPart()` Matches parts after "::" in a property access expression.
`ASToken`	`numericLiteral()` Matches a numeric literal token.
`ExpressionNodeBase`	`objectLiteralExpression()` Matches an "object literal".
`ExpressionNodeBase`	`objectLiteralValuePair()` Matches a "field" in an "object literal".
`ExpressionNodeBase`	`optExpression()` Matches an optional expression.
`void`	`optionalFunctionBody(FunctionNode f)` Matches an optional function body.
`void`	`packageContents(ContainerNode b)` Matches contents in a package block.
`void`	`packageDirective(ContainerNode c)` Matches a "package" block.
`ExpressionNodeBase`	`packageName()` Matches a package name such as: org.apache.flex A Whitespace or LineTerminator is allowed around a . in a PackageName.
`ParameterNode`	`parameter()` Matches a parameter in a function definition.
`ExpressionNodeBase`	`parenExpression()` Matches an expression with parenthesis.
`static MetaTagsNode`	`parseAtFunction(IWorkspace workspace, String metadataTagText, String sourcePath, int start, int line, int column, Collection<ICompilerProblem> problems)` Parse a String of meta data from an @function, by changing a string such as: `@Embed(source='a.png')` to: `[Embed(source='a.png')]` and then running it through the meta data parser
`static IExpressionNode`	`parseDataBinding(IWorkspace workspace, Reader reader, Collection<ICompilerProblem> problems)` Parses a databinding expression.
`static ExpressionNodeBase`	`parseExpression(IWorkspace workspace, Reader scriptReader, Collection<ICompilerProblem> problems, IProjectConfigVariables variables, ISourceLocation location)` Parse an expression from the passed in Reader.
`void`	`parseFile(FileNode fileNode, EnumSet<PostProcessStep> features)` Assemble the tokens into a parse tree with a root FileNode.
`static FileNode`	`parseFile(IFileSpecification spec, IFileSpecificationGetter fileSpecGetter)` Produces an AST from the given file input.
`static FileNode`	`parseFile(IFileSpecification spec, IFileSpecificationGetter fileSpecGetter, EnumSet<PostProcessStep> postProcess, IProjectConfigVariables variables, boolean followIncludes)` Produces an AST from the given file input.
`static FileNode`	`parseFile(IFileSpecification spec, IFileSpecificationGetter fileSpecGetter, EnumSet<PostProcessStep> postProcess, IProjectConfigVariables variables, boolean followIncludes, boolean allowEmbeds, List<String> includedFiles, DeferFunctionBody deferFunctionBody, IASProject flashProject, ICompilationUnit compilationUnit)` Produces an AST from the given file input.
`static ScopedBlockNode`	`parseFragment2(String fragment, String path, int offset, int line, int column, Collection<ICompilerProblem> problems, IWorkspace workspace, IFileNodeAccumulator fileNodeAccumulator, ASScope containingScope, IProjectConfigVariables variables, EnumSet<PostProcessStep> postProcess, boolean followIncludes, IncludeHandler includeHandler)` Parse a fragment of ActionScript.
`static void`	`parseFunctionBody(ScopedBlockNode container, Reader reader, String path, ASToken blockOpenToken, Collection<ICompilerProblem> problems, IWorkspace workspace, FileNode fileNode, ConfigProcessor configProcessor)` Parser entry-point for rebuild function body nodes.
`static ScopedBlockNode`	`parseInlineScript(IFileNodeAccumulator fileNodeAccumulator, IMXMLTextData mxmlTextData, Collection<ICompilerProblem> problems, ASScope containingScope, IProjectConfigVariables variables, IncludeHandler includeHandler, EnumSet<PostProcessStep> postProcess)` Parse a script tag with inline ActionScript.
`static MetaTagsNode`	`parseMetadata(IWorkspace workspace, String metadataContent, String sourcePath, int start, int line, int column, Collection<ICompilerProblem> problems)` Parse metadata tags from a string.
`protected void`	`parseMetadata(antlr.Token attributeToken, Collection<ICompilerProblem> problems)` Parse metadata tags with a forked sub-parser.
`static IASNode[]`	`parseProjectConfigVariables(IWorkspace workspace, String fragment, Collection<ICompilerProblem> problems)` Parses a string into a name valid in ActionScript.
`ExpressionNodeBase`	`postfixExpr()` Matches "Postfix Expression" such as: i++, i-- Since ECMA semicolon insertion rule requires that if a "++" or "--" is not on the same line as its left-hand side expression, a semicolon is inserted before the "--" or "++" token.
`UnaryOperatorNodeBase`	`postfixOp(ExpressionNodeBase n)` Matches a "postfix" operator such as: ++, -- The parameter "n" is the expression the postfix operator acts on.
`protected ExpressionNodeBase`	`precedenceParseExpression(int prec)` Operator precedence parser.
`protected void`	`preCheckMetadata(antlr.Token attributeToken, ContainerNode container)` Determines if the current metadata is found within a pure statement context, or if it is going to be bound to a definition.
`ExpressionNodeBase`	`prefixExpression()` Matches a "prefix expression".
`ExpressionNodeBase`	`primaryExpression()` Matches a primary expression.
`ExpressionNodeBase`	`propertyAccessExpression(ExpressionNodeBase l)` Matches a property access expression: For example: (assuming 'foo' is already matched) foo.bar foo..bar foo::bar foo[bar] foo.
`ExpressionNodeBase`	`propertyName()` Matches a property name in a member expression.
`protected void`	`recoverFromExpressionStatementMissingSemicolon(ExpressionNodeBase e)` Recover from `CanNotInsertSemicolonProblem` after an expression statement.
`protected void`	`recoverFromMetadataTag(ContainerNode container, ArrayLiteralNode arrayLiteralNode)` Recover from metadata parsing failure.
`protected void`	`reportFunctionBodyMissingLeftBraceProblem()` An optional function body can either be a function block or a semicolon (virtual semicolon).
`protected void`	`reportUnexpectedTokenProblem(ASToken token)` Report unexpected token problem.
`ParameterNode`	`restParameter()` Matches the "rest parameters" in a function definition. ...args
`ExpressionNodeBase`	`restrictedName()` Matches a restricted name.
`IdentifierNode`	`restrictedNamePart()` Matches the identifier part of a restricted name.
`void`	`resultType(BaseTypedDefinitionNode result)` Matches a result type: either a "void" keyword or a restricted name.
`void`	`returnStatement(ContainerNode c)` Matches a "return" statement.
`void`	`rewind(int pos)`
`ExpressionNodeBase`	`runtimeName()` Matches a runtime attribute name.
`void`	`setAllowEmbeds(boolean allowEmbeds)`
`protected void`	`setAllowErrorsInContext(boolean allow)`
`protected void`	`setConfigProcessor(ConfigProcessor configProcessor)` Bind the current parser to the given `ConfigProcessor`.
`protected void`	`setOffsetsOfEmptyBlock(IASToken blockToken, BlockNode block)` Set the offsets of an empty BlockNode generated from a {} token.
`void`	`setProjectConfigVariables(IProjectConfigVariables variables)` Sets the `IProjectConfigVariables` to be used to support conditional compilation
`VariableNode`	`singleVariable(IASToken keyword, INamespaceDecorationNode namespace)` Matches a single variable/constant definition.
`ExpressionNodeBase`	`singleVariableDefExpression(ASToken varToken, boolean isConst)` Matches a single variable definition in a for loop.
`protected void`	`skipFunctionBody(FunctionNode functionNode, ASToken openT)` Consume all the tokens in a function body, excluding the open curly and close curly braces.
`IdentifierNode`	`starLiteral()` Matches a "star" literal token, and create an IdentifierNode for "*".
`void`	`statement(ContainerNode c, int exitCondition)` Matches a statement.
`ExpressionNodeBase`	`statementParenExpression()` Matches an expression in a pair of parenthesis.
`protected void`	`storeDecorations(BaseDefinitionNode decoratedNode, ContainerNode node, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Stores decorations on the given definition.
`protected void`	`storeEmbedDecoration(VariableNode variable, IMetaTagsNode metaTags)`
`protected void`	`storeVariableDecorations(VariableNode decoratedNode, ContainerNode node, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Stores decorations on the given variable definition.
`void`	`substatement(ContainerNode c)` Matches a sub-statement.
`void`	`switchStatement(ContainerNode c)` Matches a "switch" statement.
`void`	`throwsStatement(ContainerNode c)` Matches a "throw" statement.
`protected ExpressionNodeBase`	`transformToNSAccessExpression(ExpressionNodeBase left, ASToken op, ExpressionNodeBase right)` Create AST for various types of namespace access expressions.
`protected void`	`trapInvalidNamespaceAttribute(ASToken offendingNSToken)` Traps erroneous syntax like: package foo { ns1 private class T {} }
`protected void`	`trapInvalidSubstatement(ASToken offendingNSToken)` Traps erroneous syntax like: innerLabel: namespace ns1; Although the `InvalidAttributeProblem` doesn't make much sense in this context, we are just being compatible with the old ASC's behavior.
`void`	`tryStatement(ContainerNode c)` Matches a "try...catch...finally" statement.
`ExpressionNodeBase`	`type()` Matches a type reference.
`TypedExpressionNode`	`typeApplication(ExpressionNodeBase root)` Matches a "type application" part> .
`ExpressionNodeBase`	`typedNameOrStar()` Keep legacy rule for Falcon-JS.
`ExpressionNodeBase`	`unaryExpr()` Matches a "unary expression".
`ASToken`	`unaryOp()` Matches a unary operator.
`protected ICompilerProblem`	`unexpectedTokenProblem(ASToken site, IASToken.ASTokenKind expectedKind)` Log an "unexpected token" problem.
`void`	`useNamespaceDirective(ContainerNode c)` Matches "use namespace ns" directive.
`NodeBase`	`variableDefExpression()` Matches variable definitions in a for loop.
`void`	`variableDefinition(ContainerNode c, INamespaceDecorationNode namespace, List<ModifierNode> modList)` Matches a variable/constant definition.
`ASToken`	`varOrConst()` Matches keyword "var" or keyword "const".
`void`	`vectorLiteralContents(ContainerNode b)` Matches a "vector element" in a vector initializer.
`VectorLiteralNode`	`vectorLiteralExpression()` Matches a "vector initializer".
`protected void`	`verifyNamespaceAttributes(List<INamespaceDecorationNode> namespaceAttributes)` Make sure there's at most one namespace attribute found.
`IdentifierNode`	`voidLiteral()` Matches a "void" keyword token, and create an IdentifierNode for "void".
`void`	`whileStatement(ContainerNode c)` Matches a "while" loop statement.
`void`	`withStatement(ContainerNode c)` Matches a "with" statement.
`void`	`xmlAttribute(BaseLiteralContainerNode n)` Matches an XML attribute.
`void`	`xmlAttributeBlock(BaseLiteralContainerNode n)` Matches a binding expression in an XML literal attribute name.
`ExpressionNodeBase`	`xmlAttributeName()` Matches an E4X attribute name.
`void`	`xmlContentBlock(BaseLiteralContainerNode n)` Matches a binding expression in an XML literal.
`void`	`xmlElementContent(BaseLiteralContainerNode n)` Matches an expression block in XML literals.
`protected void`	`xmlEmptyTagEnd(ASToken token)` Called when a `/>` token is encountered.
`XMLLiteralNode`	`xmlInitializer()` Matches "XML literal expression".
`XMLListLiteralNode`	`xmlListInitializer()` Matches an E4X XML list expression.
`void`	`xmlMarkup()` Matches an XML comment, XML CDATA or XML PI token.
`void`	`xmlTag(BaseLiteralContainerNode n)` Matches an XML tag.
`protected void`	`xmlTagClose(ASToken token)` Called when a `</foo` token is encountered.
`protected void`	`xmlTagOpen(ASToken token)` Called when a `<foo` token is encountered.
`protected void`	`xmlTagOpenBinding(ASToken token)` Called when a `<` token is encountered.
`void`	`xmlToken(BaseLiteralContainerNode n)` Matches an E4X token that can be aggregated in "xmlTokenAggregated".
`void`	`xmlWhitespace(BaseLiteralContainerNode n)` Match XML whitespace tokens.

Methods inherited from class antlr.LLkParser
traceIn, traceOut

Methods inherited from class antlr.Parser
addMessageListener, addParserListener, addParserMatchListener, addParserTokenListener, addSemanticPredicateListener, addSyntacticPredicateListener, addTraceListener, consumeUntil, consumeUntil, defaultDebuggingSetup, getAST, getASTFactory, getFilename, getInputState, getTokenName, getTokenNames, getTokenTypeToASTClassMap, isDebugMode, match, matchNot, panic, recover, removeMessageListener, removeParserListener, removeParserMatchListener, removeParserTokenListener, removeSemanticPredicateListener, removeSyntacticPredicateListener, removeTraceListener, reportError, reportError, reportWarning, setASTFactory, setASTNodeClass, setASTNodeType, setDebugMode, setFilename, setIgnoreInvalidDebugCalls, setInputState, setTokenBuffer, traceIndent

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - _tokenNames
```
public static final String[] _tokenNames
```
  - _tokenSet_0
```
public static final antlr.collections.impl.BitSet _tokenSet_0
```
  - _tokenSet_1
```
public static final antlr.collections.impl.BitSet _tokenSet_1
```
  - _tokenSet_2
```
public static final antlr.collections.impl.BitSet _tokenSet_2
```
  - _tokenSet_3
```
public static final antlr.collections.impl.BitSet _tokenSet_3
```
  - _tokenSet_4
```
public static final antlr.collections.impl.BitSet _tokenSet_4
```
  - _tokenSet_5
```
public static final antlr.collections.impl.BitSet _tokenSet_5
```
  - _tokenSet_6
```
public static final antlr.collections.impl.BitSet _tokenSet_6
```
  - _tokenSet_7
```
public static final antlr.collections.impl.BitSet _tokenSet_7
```
  - _tokenSet_8
```
public static final antlr.collections.impl.BitSet _tokenSet_8
```
  - _tokenSet_9
```
public static final antlr.collections.impl.BitSet _tokenSet_9
```
  - _tokenSet_10
```
public static final antlr.collections.impl.BitSet _tokenSet_10
```
  - _tokenSet_11
```
public static final antlr.collections.impl.BitSet _tokenSet_11
```
  - _tokenSet_12
```
public static final antlr.collections.impl.BitSet _tokenSet_12
```
  - _tokenSet_13
```
public static final antlr.collections.impl.BitSet _tokenSet_13
```
  - _tokenSet_14
```
public static final antlr.collections.impl.BitSet _tokenSet_14
```
  - _tokenSet_15
```
public static final antlr.collections.impl.BitSet _tokenSet_15
```
  - _tokenSet_16
```
public static final antlr.collections.impl.BitSet _tokenSet_16
```
  - _tokenSet_17
```
public static final antlr.collections.impl.BitSet _tokenSet_17
```
  - _tokenSet_18
```
public static final antlr.collections.impl.BitSet _tokenSet_18
```
  - _tokenSet_19
```
public static final antlr.collections.impl.BitSet _tokenSet_19
```
  - EMPTY_CONFIGURATION
```
public static final IProjectConfigVariables EMPTY_CONFIGURATION
```
    Variable to use as an empty project configuration
  - NO_END_TOKEN
```
protected static final int NO_END_TOKEN
```
    Used to specify "directive" rule's end token as "no end token" - the parser will consume till the end of the input stream when recover from errors.
    
    See Also:
    Constant Field Values
  - buffer
```
protected IRepairingTokenBuffer buffer
```
    Our version of a token buffer that allows us to handle optional semicolons, etc
  - currentAttributes
```
protected MetaTagsNode currentAttributes
```
    Current metadata attributes. Attributes go into this container, then are pulled out when the corresponding class, function, or variable is parsed.
  - asDocDelegate
```
protected final IASParserASDocDelegate asDocDelegate
```
    IASParserASDocDelegate used to track ASDoc information.
  - errorToken
```
protected antlr.Token errorToken
```
    Last token that produced an error
  - allowEmbeds
```
protected boolean allowEmbeds
```
    Flag to determine if we should create EmbedNodes or ignore embed metadata
  - insideClass
```
protected boolean insideClass
```
    flag that tracks whether the parser is currently inside of a class definition this is "borrowed" from the old parser to deal with some ASDoc functionality
  - errors
```
protected final Set<ICompilerProblem> errors
```
    Errors we've collected as we're moving forward
  - deferFunctionBody
```
protected DeferFunctionBody deferFunctionBody
```
    True if the current input source is an ActionScript file, as opposed to AS3 scripts in MXML or other synthesized source fragments.
  - expressionMode
```
protected BaseASParser.ExpressionMode expressionMode
```
    Expression mode of the current parsing state. ASParser updates this field according to its context.
- Constructor Detail
  - ASParser
```
public ASParser(IWorkspace workspace,
        IRepairingTokenBuffer buffer)
```
    Construct an AS3 parser from a token buffer.
  - ASParser
```
public ASParser(IWorkspace workspace,
        IRepairingTokenBuffer buffer,
        boolean parsingProjectConfigVariables)
```
    Construct an AS3 parser for parsing command line config args
  - ASParser
```
protected ASParser(antlr.TokenBuffer tokenBuf,
        int k)
```
  - ASParser
```
public ASParser(antlr.TokenBuffer tokenBuf)
```
  - ASParser
```
protected ASParser(antlr.TokenStream lexer,
        int k)
```
  - ASParser
```
public ASParser(antlr.TokenStream lexer)
```
  - ASParser
```
public ASParser(antlr.ParserSharedInputState state)
```
- Method Detail
  - fileLevelDirectives
```
public final void fileLevelDirectives(ContainerNode c)
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException
```
    Matches multiple directives. This layer is added to handle parsing error in directives.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - directive
```
public final void directive(ContainerNode c,
             int endToken)
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException
```
    Matches a "directive" level input. The first couple of alternatives gated with semantic predicates are used to either disambiguate inputs, or to trap erroneous syntax.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - groupDirective
```
public final void groupDirective(ContainerNode c,
                  int endToken)
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException
```
    Matches a "group" in a "group directive". Entering a "Block" leaves the global context, but entering a "Group" doesn't.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - statement
```
public final void statement(ContainerNode c,
             int exitCondition)
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException
```
    Matches a statement. Note that the "SuperStatement" in ASL syntax spec is not explicitly defined. The "super" statements like super(args); are matched as regular "call" expressions.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - attributedDefinition
```
public final void attributedDefinition(ContainerNode c)
                                throws antlr.RecognitionException,
                                       antlr.TokenStreamException
```
    Matches an attributed definition. An "attribute" can be a namespace or a modifier.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - asDocComment
```
public final void asDocComment()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException
```
    Matches an ASDoc block.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - importDirective
```
public final void importDirective(ContainerNode c)
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException
```
    Matches an import directive. import flash.display.Sprite; import flash.events.*;
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - useNamespaceDirective
```
public final void useNamespaceDirective(ContainerNode c)
                                 throws antlr.RecognitionException,
                                        antlr.TokenStreamException
```
    Matches "use namespace ns" directive.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - groupDirectiveWithConfigVariable
```
public final void groupDirectiveWithConfigVariable(ContainerNode c,
                                    int endToken)
                                            throws antlr.RecognitionException,
                                                   antlr.TokenStreamException
```
    Matches a group of directives gated with configuration variable. CONFIG::debug { trace("debugging code"); } If the configuration variable evaluates to false, the following block will not be added to the resulting AST.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - packageDirective
```
public final void packageDirective(ContainerNode c)
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException
```
    Matches a "package" block. package mx.controls { ... }
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - configNamespace
```
public final void configNamespace(ContainerNode c)
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException
```
    Matches a "config namespace foo" directive.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - includeDirective
```
public final void includeDirective()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException
```
    Include processing is usually done in the lexer. However, this rule is added in order to support code model partitioner whose tokenizer is set to not "follow includes". In a normal AS3 compilation, the parser would never see the "include" token.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - configConditionOfDefinition
```
public final boolean configConditionOfDefinition()
                                          throws antlr.RecognitionException,
                                                 antlr.TokenStreamException
```
    Similar to "configCondition", only that the token type after "::" is "TOKEN_NAMESPACE_ANNOTATION". This rule only applies to "attributed definitions".
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - attribute
```
public final void attribute(List<ModifierNode> modifiers,
             List<INamespaceDecorationNode> namespaceAttributes)
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException
```
    Matches an attribute such as: - Modifiers: dynamic, final, native, override, static, virtual. - Namespace names. - Reserved namespace names: internal, private, public, protected. A definition can have at most one "namespace attribute". The matched attribute is added to the lists passed in as arguments.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - definition
```
public final void definition(ContainerNode c,
              INamespaceDecorationNode ns,
              List<ModifierNode> modList)
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException
```
    Matches a definition of variable, function, namespace, class or interface.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - modifierAttribute
```
public final ModifierNode modifierAttribute()
                                     throws antlr.RecognitionException,
                                            antlr.TokenStreamException
```
    Matches a "modifier attribute" such as "final", "dynamic", "override", "static" or "native".
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - namespaceModifier
```
public final ExpressionNodeBase namespaceModifier()
                                           throws antlr.RecognitionException,
                                                  antlr.TokenStreamException
```
    Matches a namespace modifier on an "attributed definition".
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - variableDefinition
```
public final void variableDefinition(ContainerNode c,
                      INamespaceDecorationNode namespace,
                      List<ModifierNode> modList)
                              throws antlr.RecognitionException,
                                     antlr.TokenStreamException
```
    Matches a variable/constant definition.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - functionDefinition
```
public final void functionDefinition(ContainerNode c,
                      INamespaceDecorationNode namespace,
                      List<ModifierNode> modList)
                              throws antlr.RecognitionException,
                                     antlr.TokenStreamException
```
    Matches a function definition. For example: private function myFunction(name:String) : void { return; }
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - namespaceDefinition
```
public final void namespaceDefinition(ContainerNode c,
                       INamespaceDecorationNode namespace,
                       List<ModifierNode> modList)
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException
```
    Matches a namespace definition. namespace ns1;
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - classDefinition
```
public final void classDefinition(ContainerNode c,
                   INamespaceDecorationNode namespace,
                   List<ModifierNode> modList)
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException
```
    Matches a class definition. For example: class Player extends my_ns::GameObject implements IPlayer { ... }
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - interfaceDefinition
```
public final void interfaceDefinition(ContainerNode c,
                       INamespaceDecorationNode namespace,
                       List<ModifierNode> modList)
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException
```
    Matches an interface definition. interface IFoo extends IBar {...}
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - configCondition
```
public final boolean configCondition()
                              throws antlr.RecognitionException,
                                     antlr.TokenStreamException
```
    Matches a config condition such as "CONFIG::debug". This rule only applies to blocks gated with configuration variable.
    
    Returns:
    Evaluated result of the configuration variable.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - breakOrContinueStatement
```
public final void breakOrContinueStatement(ContainerNode c)
                                    throws antlr.RecognitionException,
                                           antlr.TokenStreamException
```
    Matches a "break statement" or a "continue statement". For example: break; break innerLoop; continue; continue outerLoop;
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - defaultXMLNamespaceStatement
```
public final void defaultXMLNamespaceStatement(ContainerNode c)
                                        throws antlr.RecognitionException,
                                               antlr.TokenStreamException
```
    Matches a default XML namespace statement. For example: default xml namespace = "domain";
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - gotoStatement
```
public final void gotoStatement(ContainerNode c)
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException
```
    Matches a "goto" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - emptyStatement
```
public final void emptyStatement()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException
```
    Matches an empty statement which is an explicit semicolon.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - labeledStatement
```
public final void labeledStatement(ContainerNode c,
                    int exitCondition)
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException
```
    Matches a "labeled statement". For example: innerLoop: x++;
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - expressionStatement
```
public final void expressionStatement(ContainerNode c)
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException
```
    Matches an "expression statement". The ASL syntax specification says the lookahead can not be "[", "{" or "function". Legacy code requires that "<" be excluded as well.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - forStatement
```
public final void forStatement(ContainerNode c)
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException
```
    Matches a "for loop" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - ifStatement
```
public final void ifStatement(ContainerNode c)
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException
```
    Matches an "if" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - meta
```
public final void meta(ContainerNode c)
                throws antlr.RecognitionException,
                       antlr.TokenStreamException
```
    Matches a "metadata statement". [ExcludeClass()] [Bindable]
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - returnStatement
```
public final void returnStatement(ContainerNode c)
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException
```
    Matches a "return" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - switchStatement
```
public final void switchStatement(ContainerNode c)
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException
```
    Matches a "switch" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - throwsStatement
```
public final void throwsStatement(ContainerNode c)
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException
```
    Matches a "throw" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - tryStatement
```
public final void tryStatement(ContainerNode c)
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException
```
    Matches a "try...catch...finally" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - whileStatement
```
public final void whileStatement(ContainerNode c)
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException
```
    Matches a "while" loop statement. while (x > 1) { x--; }
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - doStatement
```
public final void doStatement(ContainerNode c)
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException
```
    Matches a "do...while" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - withStatement
```
public final void withStatement(ContainerNode c)
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException
```
    Matches a "with" statement.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - expression
```
public final ExpressionNodeBase expression()
                                    throws antlr.RecognitionException,
                                           antlr.TokenStreamException
```
    Matches an expression or a comma-separated expression list.
    
    Throws:
    
    antlr.RecognitionException
    
    antlr.TokenStreamException
  - innerSubstatement
```
public final void innerSubstatement(ContainerNode c)
                             throws antlr.RecognitionException,
                                    antlr.TokenStreamException
```
    From ASL syntax spec:
    InnerSubstatement is defined in the grammar for the sole purpose of specifying side conditions that disambiguate various syntactic ambiguities in a context-sensitive manner specified in Section 5. It is only used in "do statement" and "if statement" to loosen the following two cases allowed by AS3 but not by ECMA5. do x++ while (x < 10); // ES5 would require a ; after x++ if (x > 10) x++ else y++; // ES5 would require a ; after x++
    Throws: antlr.RecognitionException antlr.TokenStreamException
  substatement public final void substatement(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Matches a sub-statement. Throws: antlr.RecognitionException antlr.TokenStreamException block public final void block(ContainerNode b) throws antlr.RecognitionException, antlr.TokenStreamException Matches a block. Throws: antlr.RecognitionException antlr.TokenStreamException importName public final ExpressionNodeBase importName() throws antlr.RecognitionException, antlr.TokenStreamException Matches an "import-able" name. flash.display.Sprite; flash.events.*; Throws: antlr.RecognitionException antlr.TokenStreamException restrictedName public final ExpressionNodeBase restrictedName() throws antlr.RecognitionException, antlr.TokenStreamException Matches a restricted name. For example: my.package.name.Clock; private::myPrivateVar; UnqualifiedTypeClock; Throws: antlr.RecognitionException antlr.TokenStreamException arrayInitializer public final void arrayInitializer(ArrayLiteralNode node) throws antlr.RecognitionException, antlr.TokenStreamException Matches array literal. For example: [] ["hello", 3.14, foo] [ , x, y] [ , ,] "Holes" (empty array elements) are allowed. See "arrayElements" rule for details. Throws: antlr.RecognitionException antlr.TokenStreamException packageName public final ExpressionNodeBase packageName() throws antlr.RecognitionException, antlr.TokenStreamException Matches a package name such as: org.apache.flex A Whitespace or LineTerminator is allowed around a . in a PackageName. For example, the following is a syntactically valid package a . b { } The resulting PackageName value is equivalent to a PackageName without any intervening Whitespace and LineTerminators. Throws: antlr.RecognitionException antlr.TokenStreamException packageContents public final void packageContents(ContainerNode b) throws antlr.RecognitionException, antlr.TokenStreamException Matches contents in a package block. Throws: antlr.RecognitionException antlr.TokenStreamException identifier public final IdentifierNode identifier() throws antlr.RecognitionException, antlr.TokenStreamException Matches an identifier token. An identifier can come from different token types such as: - IDENTIFIER - namespace - get - set This is because in AS3, these elements are not reserved keyword. However they have special meaning in some syntactic contexts. See "AS3 syntax spec - 3.5 Keywords and Punctuators" for details. Throws: antlr.RecognitionException antlr.TokenStreamException initializer public final void initializer(IInitializableDefinitionNode v) throws antlr.RecognitionException, antlr.TokenStreamException Matches an initializer in a variable/constant definition. Throws: antlr.RecognitionException antlr.TokenStreamException classOrInterfaceBlock public final void classOrInterfaceBlock(BlockNode b) throws antlr.RecognitionException, antlr.TokenStreamException Matches the content block of a class definition or an interface definition. Throws: antlr.RecognitionException antlr.TokenStreamException type public final ExpressionNodeBase type() throws antlr.RecognitionException, antlr.TokenStreamException Matches a type reference. String int * Vector. foo.bar.Vector. Throws: antlr.RecognitionException antlr.TokenStreamException functionExpression public final FunctionObjectNode functionExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches an anonymous function (function closure). Throws: antlr.RecognitionException antlr.TokenStreamException formalParameters public final void formalParameters(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Matches the parameters of a function definition signature (excluding the parenthesis). arg1:int, arg2:String Throws: antlr.RecognitionException antlr.TokenStreamException resultType public final void resultType(BaseTypedDefinitionNode result) throws antlr.RecognitionException, antlr.TokenStreamException Matches a result type: either a "void" keyword or a restricted name. :void :String :int Throws: antlr.RecognitionException antlr.TokenStreamException functionBlock public final void functionBlock(FunctionNode f, ASToken openT) throws antlr.RecognitionException, antlr.TokenStreamException Matches a function block, excluding the open "{" but including the closing "}". Throws: antlr.RecognitionException antlr.TokenStreamException optionalFunctionBody public final void optionalFunctionBody(FunctionNode f) throws antlr.RecognitionException, antlr.TokenStreamException Matches an optional function body. It can either be a "block" or a "semicolon". Throws: antlr.RecognitionException antlr.TokenStreamException formal public final void formal(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Matches a single parameter in a function definition. Throws: antlr.RecognitionException antlr.TokenStreamException restParameter public final ParameterNode restParameter() throws antlr.RecognitionException, antlr.TokenStreamException Matches the "rest parameters" in a function definition. ...args Throws: antlr.RecognitionException antlr.TokenStreamException parameter public final ParameterNode parameter() throws antlr.RecognitionException, antlr.TokenStreamException Matches a parameter in a function definition. Throws: antlr.RecognitionException antlr.TokenStreamException varOrConst public final ASToken varOrConst() throws antlr.RecognitionException, antlr.TokenStreamException Matches keyword "var" or keyword "const". Throws: antlr.RecognitionException antlr.TokenStreamException voidLiteral public final IdentifierNode voidLiteral() throws antlr.RecognitionException, antlr.TokenStreamException Matches a "void" keyword token, and create an IdentifierNode for "void". Throws: antlr.RecognitionException antlr.TokenStreamException assignmentRightValue public final ExpressionNodeBase assignmentRightValue() throws antlr.RecognitionException, antlr.TokenStreamException Matches the right-hand side of an assignment expression. "public" namespace is allowed as an R-value for backward compatibility. Throws: antlr.RecognitionException antlr.TokenStreamException See Also: "CMP-335 and ASLSPEC-19" singleVariable public final VariableNode singleVariable(IASToken keyword, INamespaceDecorationNode namespace) throws antlr.RecognitionException, antlr.TokenStreamException Matches a single variable/constant definition. Throws: antlr.RecognitionException antlr.TokenStreamException chainedVariable public final ChainedVariableNode chainedVariable(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Matches a chained variable/constant definition. Throws: antlr.RecognitionException antlr.TokenStreamException variableDefExpression public final NodeBase variableDefExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches variable definitions in a for loop. Throws: antlr.RecognitionException antlr.TokenStreamException singleVariableDefExpression public final ExpressionNodeBase singleVariableDefExpression(ASToken varToken, boolean isConst) throws antlr.RecognitionException, antlr.TokenStreamException Matches a single variable definition in a for loop. Throws: antlr.RecognitionException antlr.TokenStreamException assignmentExpression public final ExpressionNodeBase assignmentExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches an "assignment expression". According to ASL sytax spec, the productions for an "assignment expression" is either a "conditional expression" or a "left-hand side expression" followed by an "assignment operator" and an "assignment expression". However, since "assignmentExpression" and "conditionaExpression" is ambiguous at indefinite look-ahead distance, this LL(1) grammar can't decide which alternative to choose. As a result, the implementation is more lenient in that an AST node for an assignment binary node will be built even the left-hand side expression is not a valid "LeftHandSideExpression", such as a constant. For example: 100 = "hello"; This statement will be parsed without syntax error, generating tree like: = / \ 100 "hello" A possible solution to this is to find out the difference between "conditional expression" and "left-hand side expression", then insert a semantic predicate before matching a "assignment operator". Throws: antlr.RecognitionException antlr.TokenStreamException statementParenExpression public final ExpressionNodeBase statementParenExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches an expression in a pair of parenthesis. It's usually used as a condition expression in if (...), while (...), etc. (....) Throws: antlr.RecognitionException antlr.TokenStreamException optExpression public final ExpressionNodeBase optExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches an optional expression. Returns: NilNode or ExpressionNodeBase. Throws: antlr.RecognitionException antlr.TokenStreamException forInitializer public final NodeBase forInitializer() throws antlr.RecognitionException, antlr.TokenStreamException Matches the "initializer" part in a for loop. Throws: antlr.RecognitionException antlr.TokenStreamException forCondition public final void forCondition(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Matches the "condition" part in a for loop. Throws: antlr.RecognitionException antlr.TokenStreamException forStep public final void forStep(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Matches the "step" part in a for loop. Throws: antlr.RecognitionException antlr.TokenStreamException catchBlock public final void catchBlock(TryNode tryNode) throws antlr.RecognitionException, antlr.TokenStreamException Matches the "catch" block in a "try" statement. Throws: antlr.RecognitionException antlr.TokenStreamException catchBlockArgument public final ParameterNode catchBlockArgument() throws antlr.RecognitionException, antlr.TokenStreamException Matches the argument in the "try...catch(arg)" statement. Throws: antlr.RecognitionException antlr.TokenStreamException elsePart public final boolean elsePart(IfNode i) throws antlr.RecognitionException, antlr.TokenStreamException Matches the optional "else" block of an "if" statement. Returns: true if there is an "else" block. Throws: antlr.RecognitionException antlr.TokenStreamException cases public final void cases(SwitchNode sw) throws antlr.RecognitionException, antlr.TokenStreamException Matches the "case" block in a "switch" statement. Throws: antlr.RecognitionException antlr.TokenStreamException caseClauses public final void caseClauses(ContainerNode swb) throws antlr.RecognitionException, antlr.TokenStreamException Matches the "case" clauses in a "switch" statement. Throws: antlr.RecognitionException antlr.TokenStreamException caseClause public final void caseClause(ContainerNode swb) throws antlr.RecognitionException, antlr.TokenStreamException Matches a single "case" clause in a "switch" statement. Throws: antlr.RecognitionException antlr.TokenStreamException colon public final void colon() throws antlr.RecognitionException, antlr.TokenStreamException Matches a colon token ":" or recover from a missing colon. Throws: antlr.RecognitionException antlr.TokenStreamException caseStatementList public final void caseStatementList(ContainerNode b) throws antlr.RecognitionException, antlr.TokenStreamException Matches the statements in a "case" clause. Throws: antlr.RecognitionException antlr.TokenStreamException starLiteral public final IdentifierNode starLiteral() throws antlr.RecognitionException, antlr.TokenStreamException Matches a "star" literal token, and create an IdentifierNode for "*". Throws: antlr.RecognitionException antlr.TokenStreamException restrictedNamePart public final IdentifierNode restrictedNamePart() throws antlr.RecognitionException, antlr.TokenStreamException Matches the identifier part of a restricted name. For example: private public foo MyType Throws: antlr.RecognitionException antlr.TokenStreamException bracketExpression public final DynamicAccessNode bracketExpression(ExpressionNodeBase root) throws antlr.RecognitionException, antlr.TokenStreamException Matches a bracket expression. For example: [10] [idx] Throws: antlr.RecognitionException antlr.TokenStreamException typedNameOrStar public final ExpressionNodeBase typedNameOrStar() throws antlr.RecognitionException, antlr.TokenStreamException Keep legacy rule for Falcon-JS. Throws: antlr.RecognitionException antlr.TokenStreamException typeApplication public final TypedExpressionNode typeApplication(ExpressionNodeBase root) throws antlr.RecognitionException, antlr.TokenStreamException Matches a "type application" part> . . . Throws: antlr.RecognitionException antlr.TokenStreamException condExpr public final ExpressionNodeBase condExpr() throws antlr.RecognitionException, antlr.TokenStreamException Matches a ternary expression such as: (x > 2) ? "greater" : "smaller" Throws: antlr.RecognitionException antlr.TokenStreamException assignOp public final ASToken assignOp() throws antlr.RecognitionException, antlr.TokenStreamException Throws: antlr.RecognitionException antlr.TokenStreamException binaryExpr public final ExpressionNodeBase binaryExpr() throws antlr.RecognitionException, antlr.TokenStreamException Binary expression uses operator precedence parser in BaseASParser. Throws: antlr.RecognitionException antlr.TokenStreamException fakeExpr public final void fakeExpr() throws antlr.RecognitionException, antlr.TokenStreamException fakeExpr simulates the set of allowable follow tokens in an expression context, which allows antlr to function. It is unreachable. Throws: antlr.RecognitionException antlr.TokenStreamException unaryExpr public final ExpressionNodeBase unaryExpr() throws antlr.RecognitionException, antlr.TokenStreamException Matches a "unary expression". This rule is called out of the precedence parser in BaseASParser. If you need to change the name of this rule, you'll also need to update the base class. Throws: antlr.RecognitionException antlr.TokenStreamException binaryOperators public final void binaryOperators() throws antlr.RecognitionException, antlr.TokenStreamException Declares all the binary operators. Throws: antlr.RecognitionException antlr.TokenStreamException prefixExpression public final ExpressionNodeBase prefixExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches a "prefix expression". delete x[i] ++i --i The distinction between this rule and "unary expression" makes the parser more strict about what expressions can follow what tokens. Throws: antlr.RecognitionException antlr.TokenStreamException postfixExpr public final ExpressionNodeBase postfixExpr() throws antlr.RecognitionException, antlr.TokenStreamException Matches "Postfix Expression" such as: i++, i-- Since ECMA semicolon insertion rule requires that if a "++" or "--" is not on the same line as its left-hand side expression, a semicolon is inserted before the "--" or "++" token. The side-effect of the inserted semicolon is to terminate the expression parsing at this point. As a result, we have to return "null" to stop parsing the expression. An upstream production will pickup the "--" or "++" by starting a new expression. A good test case for such situation would be: var i = 99 ++i A semicolon should be inserted after "99", resulting in two separate ASTs for "var i=99" and "++i". Otherwise, "var i=99++" is a bad recognition. Throws: antlr.RecognitionException antlr.TokenStreamException lhsExpr public final ExpressionNodeBase lhsExpr() throws antlr.RecognitionException, antlr.TokenStreamException Matches a left-hand side (of asssignment) expression. Throws: antlr.RecognitionException antlr.TokenStreamException unaryOp public final ASToken unaryOp() throws antlr.RecognitionException, antlr.TokenStreamException Matches a unary operator. Throws: antlr.RecognitionException antlr.TokenStreamException propertyAccessExpression public final ExpressionNodeBase propertyAccessExpression(ExpressionNodeBase l) throws antlr.RecognitionException, antlr.TokenStreamException Matches a property access expression: For example: (assuming 'foo' is already matched) foo.bar foo..bar foo::bar foo[bar] foo. Throws: antlr.RecognitionException antlr.TokenStreamException arguments public final ExpressionNodeBase arguments(ExpressionNodeBase root) throws antlr.RecognitionException, antlr.TokenStreamException Matches the arguments of a function call: allcharacters between (...) including the parenthesis. foo(true, 10, "hello"); new MyData(100, "hundred"); "newExpression" rule always creates a FunctionCallNode and passes it in as the "root". Since the "newExpression" rule uses "arguments" rule to consume its arguments, we don't need to create a new FunctionCallNode because the "root" parameter is the FunctionCallNode to which the arguments belongs. On the other hand, if the "root" argument is not a FunctionCallNode from a "new" expression, then the "root" can only be the "name expression" of a function call. As a result, we must create a FunctionCallNode for it. For example: myFunc() -- the name expression is identifier "myFunc" token.getCallBack()() -- the name expression is "token.getCallBack()" expecting the return value of "getCallBack" to be a function object. [Shaoting] We could also make newExpression rule not create a FunctionCallNode inside the "newExpression" rule, and pass in the "new" token so that all FunctionCallNode are constructed in this rule. However, we want the parser to construct nodes as early as possible for IDE features. For example: "new T" without "(..)" would not result in a FunctionCallNode if we don't create it right after we see "T". Throws: antlr.RecognitionException antlr.TokenStreamException postfixOp public final UnaryOperatorNodeBase postfixOp(ExpressionNodeBase n) throws antlr.RecognitionException, antlr.TokenStreamException Matches a "postfix" operator such as: ++, -- The parameter "n" is the expression the postfix operator acts on. The return value "top" is a UnaryOperatorNode. Throws: antlr.RecognitionException antlr.TokenStreamException primaryExpression public final ExpressionNodeBase primaryExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches a primary expression. Throws: antlr.RecognitionException antlr.TokenStreamException numericLiteral public final ASToken numericLiteral() throws antlr.RecognitionException, antlr.TokenStreamException Matches a numeric literal token. Throws: antlr.RecognitionException antlr.TokenStreamException objectLiteralExpression public final ExpressionNodeBase objectLiteralExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches an "object literal". Throws: antlr.RecognitionException antlr.TokenStreamException xmlInitializer public final XMLLiteralNode xmlInitializer() throws antlr.RecognitionException, antlr.TokenStreamException Matches "XML literal expression". Throws: antlr.RecognitionException antlr.TokenStreamException xmlListInitializer public final XMLListLiteralNode xmlListInitializer() throws antlr.RecognitionException, antlr.TokenStreamException Matches an E4X XML list expression. Throws: antlr.RecognitionException antlr.TokenStreamException objectLiteralValuePair public final ExpressionNodeBase objectLiteralValuePair() throws antlr.RecognitionException, antlr.TokenStreamException Matches a "field" in an "object literal". The "field" can be gated with a "config condition". If the condition is "false", return "null" value; Otherwise, return the expression node of the key/value pair. Throws: antlr.RecognitionException antlr.TokenStreamException arrayElements public final void arrayElements(ContainerNode b) throws antlr.RecognitionException, antlr.TokenStreamException Matches all the elements in an "arrayInitializer". For example: x,y,z x,, (empty) ,,,,,, "Holes" are compiled as "undefined". Leading "holes" are kept as "undefined" values. "Holes" in the middle are kept as "undefined" values. Trailing "holes" are kept as "undefined" values except that the last "hole" is dropped. For example: x=[,,1,,,2,,,] has 2 leading holes, 2 holes in the middle, and 3 holes at the end. All the holes except for the last trailing holes are kept as undefined values: x[0]=undefined x[1]=undefined x[2]=1 x[3]=undefined x[4]=undefined x[5]=2 x[6]=undefined x[7]=undefined (end) Throws: antlr.RecognitionException antlr.TokenStreamException arrayElement public final ExpressionNodeBase arrayElement() throws antlr.RecognitionException, antlr.TokenStreamException Matches an "array element" in an "array literal". An array element can be gated with a config variable. If the config variable is false, the element will be matched as a "hole" in the array literal. Throws: antlr.RecognitionException antlr.TokenStreamException vectorLiteralExpression public final VectorLiteralNode vectorLiteralExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches a "vector initializer". Throws: antlr.RecognitionException antlr.TokenStreamException vectorLiteralContents public final void vectorLiteralContents(ContainerNode b) throws antlr.RecognitionException, antlr.TokenStreamException Matches a "vector element" in a vector initializer. Throws: antlr.RecognitionException antlr.TokenStreamException xmlMarkup public final void xmlMarkup() throws antlr.RecognitionException, antlr.TokenStreamException Matches an XML comment, XML CDATA or XML PI token. Throws: antlr.RecognitionException antlr.TokenStreamException xmlWhitespace public final void xmlWhitespace(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Match XML whitespace tokens. If ContainerNode is null, drop the whitespace tokens. Throws: antlr.RecognitionException antlr.TokenStreamException xmlElementContent public final void xmlElementContent(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Matches an expression block in XML literals. { this.fooValue } Throws: antlr.RecognitionException antlr.TokenStreamException xmlToken public final void xmlToken(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Matches an E4X token that can be aggregated in "xmlTokenAggregated". Instead of a full recursive descent parser for XML tags, the base class uses a tag name stack to check matching tags. A complete parse tree with XML structure is unnecessary and adds extra overhead to the parser. Throws: antlr.RecognitionException antlr.TokenStreamException xmlTag public final void xmlTag(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Matches an XML tag. <{name}> Throws: antlr.RecognitionException antlr.TokenStreamException xmlContentBlock public final void xmlContentBlock(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Matches a binding expression in an XML literal. Throws: antlr.RecognitionException antlr.TokenStreamException xmlAttribute public final void xmlAttribute(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Matches an XML attribute. name="value" name='value' name={value} {name}="value" {name}='value' {name}={value} Throws: antlr.RecognitionException antlr.TokenStreamException xmlAttributeBlock public final void xmlAttributeBlock(BaseLiteralContainerNode n) throws antlr.RecognitionException, antlr.TokenStreamException Matches a binding expression in an XML literal attribute name. Throws: antlr.RecognitionException antlr.TokenStreamException newExpression public final ExpressionNodeBase newExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches a new expression. See ASL syntax spec for details. Throws: antlr.RecognitionException antlr.TokenStreamException parenExpression public final ExpressionNodeBase parenExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches an expression with parenthesis. (id) (1 + 2) (name == "hello") Throws: antlr.RecognitionException antlr.TokenStreamException nameExpression public final ExpressionNodeBase nameExpression() throws antlr.RecognitionException, antlr.TokenStreamException This is a non-greedy and non-aggregating version of "restricted name". It is defined in addition to "propertyName" in order to get correct precedence in the name expressions and expected tree shapes. Throws: antlr.RecognitionException antlr.TokenStreamException xmlAttributeName public final ExpressionNodeBase xmlAttributeName() throws antlr.RecognitionException, antlr.TokenStreamException Matches an E4X attribute name. For example: "@*", @data, @[foo="hello"] Throws: antlr.RecognitionException antlr.TokenStreamException memberExpression public final ExpressionNodeBase memberExpression() throws antlr.RecognitionException, antlr.TokenStreamException Matches a member expression. See ASL syntax spec for details. Throws: antlr.RecognitionException antlr.TokenStreamException propertyName public final ExpressionNodeBase propertyName() throws antlr.RecognitionException, antlr.TokenStreamException Matches a property name in a member expression. Throws: antlr.RecognitionException antlr.TokenStreamException accessPart public final ExpressionNodeBase accessPart() throws antlr.RecognitionException, antlr.TokenStreamException Matches parts after the dot in a property access expression. Throws: antlr.RecognitionException antlr.TokenStreamException nsAccessPart public final ExpressionNodeBase nsAccessPart() throws antlr.RecognitionException, antlr.TokenStreamException Matches parts after "::" in a property access expression. Throws: antlr.RecognitionException antlr.TokenStreamException runtimeName public final ExpressionNodeBase runtimeName() throws antlr.RecognitionException, antlr.TokenStreamException Matches a runtime attribute name. foo["name"] Throws: antlr.RecognitionException antlr.TokenStreamException argumentList public final void argumentList(ContainerNode args) throws antlr.RecognitionException, antlr.TokenStreamException Matches an argument list in a function call arguments. For argument list, we want to support the case where the user might be in the middle of typing, which could mean a couple of things: 1. The user adds an argument before another. 2. After which could lead to comma where we don't want it. Throws: antlr.RecognitionException antlr.TokenStreamException parseFile public static FileNode parseFile(IFileSpecification spec, IFileSpecificationGetter fileSpecGetter) Produces an AST from the given file input. A FileNode will always be returned, however it is not guaranteed to contain any content. This is provided as a convenience, as it is equivalent to calling: parseFile(spec, workspace, EnumSet.of(PostProcessStep.CALCULATE_OFFSETS), true, true) meaning we follow includes, fix the tree and calculate offsets. Parameters: spec - the IFileSpecification that points to the file that will be parsed fileSpecGetter - the IFileSpecificationGetter that should be used to open files. Returns: a FileNode built from the given input parseFile public static FileNode parseFile(IFileSpecification spec, IFileSpecificationGetter fileSpecGetter, EnumSet<PostProcessStep> postProcess, IProjectConfigVariables variables, boolean followIncludes) Produces an AST from the given file input. A FileNode will always be returned, however it is not guaranteed to contain any content Parameters: spec - the IFileSpecification that points to the file that will be parsed fileSpecGetter - the IFileSpecificationGetter that should be used to open files. postProcess - the set of operations we want to perform on this tree before it is returned. See PostProcessStep variables - the IProjectConfigVariables containing project-level conditional compilation variables followIncludes - flag to determine if include statements should be followed Returns: a FileNode built from the given input parseFile public static FileNode parseFile(IFileSpecification spec, IFileSpecificationGetter fileSpecGetter, EnumSet<PostProcessStep> postProcess, IProjectConfigVariables variables, boolean followIncludes, boolean allowEmbeds, List<String> includedFiles, DeferFunctionBody deferFunctionBody, IASProject flashProject, ICompilationUnit compilationUnit) Produces an AST from the given file input. A FileNode will always be returned, however it is not guaranteed to contain any content Parameters: spec - the IFileSpecification that points to the file that will be parsed postProcess - the set of operations we want to perform on this tree before it is returned. See PostProcessStep variables - the IProjectConfigVariables containing project-level conditional compilation variables followIncludes - flag to determine if include statements should be followed allowEmbeds - flag to indicate if we should ignore embed meta data or create EmbedNodes includedFiles - Files included by asc -in option. flashProject - Used to resolve included files in all the source folders. Use null if the project is not a IASProject. compilationUnit - used to manage missing include files. both project and compilation unit must be passed if you wish to have compilation units re-built when their missing referenced files are added to the project. Returns: a FileNode built from the given input parseFragment2 public static ScopedBlockNode parseFragment2(String fragment, String path, int offset, int line, int column, Collection<ICompilerProblem> problems, IWorkspace workspace, IFileNodeAccumulator fileNodeAccumulator, ASScope containingScope, IProjectConfigVariables variables, EnumSet<PostProcessStep> postProcess, boolean followIncludes, IncludeHandler includeHandler) Parse a fragment of ActionScript. The resulting AST node is the return value. The resulting definitions and scopes will be attached to the given containingScope. This is used by MXML script tags. Parameters: fragment - ActionScript block. path - Containing source path of the ActionScript fragment. offset - Start offset of the script. line - Line offset of the script. column - Column offset of the script. problems - Problems parsing the script. workspace - Owner workspace. fileNodeAccumulator - Collect data that needs to be stored on FileNode. containingScope - The resulting definitions and scopes from the script will be attached to this scope. variables - Project config variables. postProcess - Post process steps. followIncludes - True if includes are followed. includeHandler - The include handler to use. Returns: The resulting AST subtree generated from the ActionScript fragment. parseFunctionBody public static void parseFunctionBody(ScopedBlockNode container, Reader reader, String path, ASToken blockOpenToken, Collection<ICompilerProblem> problems, IWorkspace workspace, FileNode fileNode, ConfigProcessor configProcessor) Parser entry-point for rebuild function body nodes. Parameters: container - Function body container node. reader - Function body reader. path - Source path. blockOpenToken - "{" of the function body. problems - Compiler problems. workspace - Current workspace. fileNode - AS file node. configProcessor - Configuration variables. parseInlineScript public static ScopedBlockNode parseInlineScript(IFileNodeAccumulator fileNodeAccumulator, IMXMLTextData mxmlTextData, Collection<ICompilerProblem> problems, ASScope containingScope, IProjectConfigVariables variables, IncludeHandler includeHandler, EnumSet<PostProcessStep> postProcess) Parse a script tag with inline ActionScript. This function does not trigger "enter" and "leave" event for the inlined script, because the script's token offset is still in the same offset space with its parent document. Both MXMLScopeBuilder and MXMLScriptNode use this parser entry point. Different post-process tasks are requested. parseExpression public static ExpressionNodeBase parseExpression(IWorkspace workspace, Reader scriptReader, Collection<ICompilerProblem> problems, IProjectConfigVariables variables, ISourceLocation location) Parse an expression from the passed in Reader. This method can handle expressions that are inline (such as the body of a Function tag) or expressions that just come from a java String. For the inline case, the Reader should be a SourceFragmentsReader - it is up to the caller to set up the SourceFragmentsReader correctly - see MXMLExpressionNodeBase.parseExpressionFromTag. For the String case, the Reader can just be a StringReader. This will parse an Expression from the Reader and return the ExpressionNodeBase. It will return null, if there is no expression, or it can't be parsed. parseProjectConfigVariables public static final IASNode[] parseProjectConfigVariables(IWorkspace workspace, String fragment, Collection<ICompilerProblem> problems) Parses a string into a name valid in ActionScript. If the code is not valid or does not yield an identifier, null will be returned Parameters: fragment - the string that contains a name Returns: an IIdentifierNode, or null parseDataBinding public static final IExpressionNode parseDataBinding(IWorkspace workspace, Reader reader, Collection<ICompilerProblem> problems) Parses a databinding expression. addConditionalCompilationNamespace protected final void addConditionalCompilationNamespace(NamespaceNode node) setProjectConfigVariables public void setProjectConfigVariables(IProjectConfigVariables variables) Sets the IProjectConfigVariables to be used to support conditional compilation Parameters: variables - IProjectConfigVariables for the given context setConfigProcessor protected final void setConfigProcessor(ConfigProcessor configProcessor) Bind the current parser to the given ConfigProcessor. Parameters: configProcessor - Resolve configuration variables at parse-time. evaluateConstNodeExpression protected final LiteralNode evaluateConstNodeExpression(ConfigExpressionNode node) isConfigNamespace protected final boolean isConfigNamespace(NamespaceIdentifierNode id) getSyntaxProblems public Collection<ICompilerProblem> getSyntaxProblems() disconnect protected final void disconnect() Close the parser and release resources. getSourceFilePath public String getSourceFilePath() Description copied from interface: IProblemReporter Gets the source file that we are reporting for Specified by: getSourceFilePath in interface IProblemReporter Returns: the source file setAllowErrorsInContext protected void setAllowErrorsInContext(boolean allow) addProblem public void addProblem(ICompilerProblem problem) Description copied from interface: IProblemReporter Adds an ICompilerProblem to this reporter Specified by: addProblem in interface IProblemReporter Parameters: problem - an ICompilerProblem setAllowEmbeds public void setAllowEmbeds(boolean allowEmbeds) parseFile public void parseFile(FileNode fileNode, EnumSet<PostProcessStep> features) Assemble the tokens into a parse tree with a root FileNode. Parameters: fileNode - The parser builds AST into this root FileNode. features - Post-process steps to be performed. encounteredImport protected void encounteredImport(ImportNode importNode) parseAtFunction public static MetaTagsNode parseAtFunction(IWorkspace workspace, String metadataTagText, String sourcePath, int start, int line, int column, Collection<ICompilerProblem> problems) Parse a String of meta data from an @function, by changing a string such as: @Embed(source='a.png') to: [Embed(source='a.png')] and then running it through the meta data parser Parameters: metadataTagText - The @function text. problems - The collection of compiler problems to which this method will add problems. Returns: MetaTagsNode or null if error parsing the meta data parseMetadata public static MetaTagsNode parseMetadata(IWorkspace workspace, String metadataContent, String sourcePath, int start, int line, int column, Collection<ICompilerProblem> problems) Parse metadata tags from a string. Parameters: workspace - Current workspace. metadataContent - Source text. sourcePath - Source path. start - Start offset. line - Line offset. column - Column offset. problems - Problem collection. Returns: A MetaTagsNode containing all the parsed metadata tags. parseMetadata protected final void parseMetadata(antlr.Token attributeToken, Collection<ICompilerProblem> problems) Parse metadata tags with a forked sub-parser. Parameters: attributeToken - Metadata token. problems - Problem collection. preCheckMetadata protected final void preCheckMetadata(antlr.Token attributeToken, ContainerNode container) Determines if the current metadata is found within a pure statement context, or if it is going to be bound to a definition. If the item is free-floating (not about to be bound to a definition) then we set its parent as the passed in container, and log an error. Parameters: attributeToken - the token that contains the metadata container - the ContainerNode we will potentially add our metadata to as a child isConfigCondition protected final boolean isConfigCondition() Check if the look-ahead can be matched as a "ConfigCondition". Returns: True if the following input is "ConfigCondition". isXMLAttribute protected final boolean isXMLAttribute() Check if the look-ahead can be matched as a "XMLAttribute". Returns: True if the following input is "XMLAttribute". storeVariableDecorations protected void storeVariableDecorations(VariableNode decoratedNode, ContainerNode node, INamespaceDecorationNode namespace, List<ModifierNode> modList) Stores decorations on the given variable definition. This will set any collected modifiers, namespace, metadata or comment we've encountered Parameters: decoratedNode - node - storeEmbedDecoration protected void storeEmbedDecoration(VariableNode variable, IMetaTagsNode metaTags) storeDecorations protected void storeDecorations(BaseDefinitionNode decoratedNode, ContainerNode node, INamespaceDecorationNode namespace, List<ModifierNode> modList) Stores decorations on the given definition. This will set any collected modifiers, namespace, metadata or comment we've encountered Parameters: decoratedNode - node - namespaceIsConfigNamespace protected final boolean namespaceIsConfigNamespace(INamespaceDecorationNode node) logMultipleConfigNamespaceDecorationsError protected void logMultipleConfigNamespaceDecorationsError(NodeBase source) checkNamespaceDefinition protected void checkNamespaceDefinition(NamespaceNode ns) Check if the namespace conflicts with a config namespace Parameters: ns - the NamespaceNode to check transformToNSAccessExpression protected final ExpressionNodeBase transformToNSAccessExpression(ExpressionNodeBase left, ASToken op, ExpressionNodeBase right) Create AST for various types of namespace access expressions. Parameters: left - left-hand side of :: is the namespace expression op - :: token right - right-hand side of :: is the variable Returns: AST for the namespace access expressions. checkForChainedNamespaceQualifierProblem protected final void checkForChainedNamespaceQualifierProblem(ASToken nsAccessOp, ExpressionNodeBase right) Check for syntax error of chained namespace qualifiers: ns1::ns2::ns3::foo = 10; setOffsetsOfEmptyBlock protected void setOffsetsOfEmptyBlock(IASToken blockToken, BlockNode block) Set the offsets of an empty BlockNode generated from a {} token. Parameters: blockToken - {} token block - BlockNode corresponding to that token disableSemicolonInsertion protected final void disableSemicolonInsertion() enableSemicolonInsertion protected final void enableSemicolonInsertion() consumeParsingError protected final void consumeParsingError(antlr.RecognitionException ex, int endToken) Create a syntax error or warning based on the RecognitionException. Parameters: ex - ANTLR-generated parsing exception. endToken - The expected end token for the currently parsing fragment. It is used to determine the compiler problem type to create. consumeParsingError protected final void consumeParsingError(antlr.RecognitionException ex) See Also: consumeParsingError(RecognitionException, int) expectingIdentifier protected IdentifierNode expectingIdentifier(antlr.NoViableAltException ex) Force the parser to report a MismatchedTokenException when failed to parse an identifier. The reason is that an identifier can either be an IDENTIFIER token or one of the "contextual reserved words" like namespace. Since we always want the error message to be "Expected ... but got ....", we convert the exception here. Parameters: ex - NoViableAltException thrown in identifier(). Returns: missing identifier handleMissingIdentifier protected IdentifierNode handleMissingIdentifier(antlr.RecognitionException ex) handles a case where we expected an identifier but our production produced an error, while we were trying to produce a short name. If tree fixing is enabled, this will return a new identifier to make the tree "correct" Parameters: ex - the exception that was thrown Returns: an IdentifierNode or null if tree fixing is not turned on handleMissingIdentifier protected ExpressionNodeBase handleMissingIdentifier(antlr.RecognitionException ex, ExpressionNodeBase n) handles a case where we expected an identifier but our production produced an error, while we were trying to produce a dotted name. If tree fixing is enabled, this will return a new identifier to make the tree "correct" Parameters: ex - the exception that was thrown Returns: an IdentifierNode or null if tree fixing is not turned on logSyntaxError protected final void logSyntaxError(ASToken badToken) Logs a syntax error against the given token Parameters: badToken - the token that caused the syntax error handleParsingError protected boolean handleParsingError(antlr.RecognitionException ex, int endToken) Called by the parser to handle specific error cases we come across. If the error handler can fix the error to potentially yield a successful production then true is returned by this method. This method may insert tokens into the token stream, or change the types of tokens that produced the error. Parameters: ex - the exception thrown by the parser endToken - expected end token Returns: true if this error case can potentially be fixed handleParsingError protected boolean handleParsingError(antlr.RecognitionException ex) See Also: handleParsingError(RecognitionException, int) endContainerAtError protected void endContainerAtError(antlr.RecognitionException ex, NodeBase node) consume public final void consume() Overrides: consume in class antlr.LLkParser matchOptionalSemicolon protected boolean matchOptionalSemicolon() Match optional semicolon. This method will report a CanNotInsertSemicolonProblem if a "virtual semicolon" is expected but failed to be inserted, except when there's already a syntax error on the same line, because the preceding syntax error might early-terminate a statement, making the parser to expect a optional semicolon. It's not "wrong" to always report the semicolon problem. However, it would make too much "noise" on the console, and it would break almost all negative ASC tests. Returns: True if optional semicolon is matched. See Also: IRepairingTokenBuffer.matchOptionalSemicolon() reportFunctionBodyMissingLeftBraceProblem protected void reportFunctionBodyMissingLeftBraceProblem() An optional function body can either be a function block or a semicolon (virtual semicolon). If neither is matched, a MissingLeftBraceBeforeFunctionBodyProblem occurs. However, we only report the problem if the function definition parsing doesn't have other syntax issues so far. consumeUntilKeywordOrIdentifier protected void consumeUntilKeywordOrIdentifier(int exitCondition) Consume until one of the following tokens: keyword identifier EOF metadata tag ASDoc comment token type of the given exit condition Parameters: exitCondition - Stop if the next token type matches the exit condition. consumeUntilKeywordOr protected void consumeUntilKeywordOr(Integer... types) Consume until a keyword, EOF or specified token types. Parameters: types - Stop if the next token's type is one of these. match public final void match(int t) throws antlr.MismatchedTokenException, antlr.TokenStreamException Overrides: match in class antlr.Parser Throws: antlr.MismatchedTokenException antlr.TokenStreamException LA public final int LA(int i) Overrides: LA in class antlr.LLkParser LT public final ASToken LT(int i) Overrides: LT in class antlr.LLkParser mark public final int mark() Overrides: mark in class antlr.Parser rewind public final void rewind(int pos) Overrides: rewind in class antlr.Parser precedenceParseExpression protected final ExpressionNodeBase precedenceParseExpression(int prec) throws antlr.RecognitionException, antlr.TokenStreamException Operator precedence parser. Refer to Vaughan Pratt, "top down operator precedence parsing" or Dijkstra's shunting yard algorithm, or precedence climbing. Throws: antlr.RecognitionException antlr.TokenStreamException foundExtraCharacterAfterEndOfProgram protected void foundExtraCharacterAfterEndOfProgram(ASToken token) Call this method when extra characters were found after the end of the program. The ExtraCharactersAfterEndOfProgramProblem is only logged when it's the first error in the current file. Even though this method might be called multiple times because of the parser recovery logic, such problem can only be reported once. Parameters: token - Token recognized as "extra characters". afterRestrictedToken protected boolean afterRestrictedToken(ASToken current) Call this method in the grammar once a "restricted token" is matched. According to ECMA-262 Section 7.9.1: When, as the program is parsed from left to right, a token is encountered that is allowed by some production of the grammar, but the production is a restricted production and the token would be the first token for a terminal or nonterminal immediately following the annotation [no LineTerminator here] within the restricted production (and therefore such a token is called a restricted token), and the restricted token is separated from the previous token by at least one LineTerminator, then a semicolon is automatically inserted before the restricted token. These are the only restricted productions in ECMA grammar: Expression [no LineTerminator] ++ Expression [no LineTerminator] -- continue [no LineTerminator] Identifier break [no LineTerminator] Identifier return [no LineTerminator] Expression throw [no LineTerminator] Expression As a result, this method should be called after these tokens are matched: continue, break, return, throw. Parameters: current - The current token should be the restricted token. Returns: True if the semicolon is inserted. beforeRestrictedToken protected boolean beforeRestrictedToken(ASToken nextToken) See Javadoc for afterRestrictedToken(ASToken) for details about "restricted token" and semicolon insertion. Parameters: nextToken - The next token should be the restricted token. Returns: True if the semicolon is inserted. See Also: afterRestrictedToken(ASToken) unexpectedTokenProblem protected final ICompilerProblem unexpectedTokenProblem(ASToken site, IASToken.ASTokenKind expectedKind) Log an "unexpected token" problem. Parameters: site - offending token expectedKind - expected token kind Returns: UnexpectedTokenProblem instance. verifyNamespaceAttributes protected void verifyNamespaceAttributes(List<INamespaceDecorationNode> namespaceAttributes) Make sure there's at most one namespace attribute found. Report syntax problem otherwise. Parameters: namespaceAttributes - A list of namespace attributes. recoverFromExpressionStatementMissingSemicolon protected final void recoverFromExpressionStatementMissingSemicolon(ExpressionNodeBase e) Recover from CanNotInsertSemicolonProblem after an expression statement. Such error pattern is usually a sign of invalid code being parsed as expressions. Recover from contextual keywords When there's syntax errors, the token transformation logic in StreamingASTokenizer might fail. For example, a contextual reserved keyword like "static" is labeled as "identifier" instead of "modifier" when the token following "static" doesn't start a definition. As a result "static" is parsed as a single variable "expressionStatement", and the following content will be reported with a CanNotInsertSemicolonProblem. Since we want the error reporting to be user-friendly, we need to detect such cases and override the compiler problems. The pattern is simple: an ExpressionNodeBase of type IdentifierNode and it's identifier name is one of the contextual reserved keywords: dynamic, final, native, static and override. Recover from invalid labels When the next offending token is colon, it means the parsed expression isn't a valid label identifier. Parameters: e - The AST created for the parsed expression. trapInvalidSubstatement protected void trapInvalidSubstatement(ASToken offendingNSToken) Traps erroneous syntax like: innerLabel: namespace ns1; Although the InvalidAttributeProblem doesn't make much sense in this context, we are just being compatible with the old ASC's behavior. Parameters: offendingNSToken - The offending "namespace" token after the label and colon. trapInvalidNamespaceAttribute protected void trapInvalidNamespaceAttribute(ASToken offendingNSToken) Traps erroneous syntax like: package foo { ns1 private class T {} } Parameters: offendingNSToken - The unexpected namespace name token. evaluateConfigurationVariable protected boolean evaluateConfigurationVariable(IdentifierNode configNamespace, ASToken opToken, IdentifierNode configVar) Evaluate configuration variable result. Parameters: configNamespace - The configuration namespace. opToken - The operator token. Always "::". configVar - The unqualified configuration variable name. Returns: True if the qualified configuration variable evaluates to true. reportUnexpectedTokenProblem protected final void reportUnexpectedTokenProblem(ASToken token) Report unexpected token problem. Parameters: token - Offending token. skipFunctionBody protected final void skipFunctionBody(FunctionNode functionNode, ASToken openT) Consume all the tokens in a function body, excluding the open curly and close curly braces. In order to allow lazy-parsing of the skipped function bodies, the contents need to be cached. We can't cache all the tokens because they take up huge amount of memory. On the other hand, we can't cache the text of the function body by accessing the underlying Reader directly, because it isn't guaranteed to point to the start of the function block when then the parser sees the function body due to the possible "look-ahead" operations triggered by the tokenizer. As a result, it leaves us the only option which is to capture the start and end character offsets of the function body. Since Reader.skip(long) is slow, the parser keeps a secondary Reader (secondaryReader) in order to cache the text of the function body on-the-fly. The text is stored on the corresponding FunctionNode. This feature is turn on only all of the following conditions are true: The source is from a readable ActionScript source file. The function is not a function closure. The source file is not an in-memory compilation (see IInvisibleCompilationUnit) unit in the editor. Parameters: functionNode - Function node. openT - The open curly token of the function body. See Also: Deferring function body nodes enterPackage protected final void enterPackage(ASToken keywordPackage) Increment package depth counter and check for NestedPackageProblem. Parameters: keywordPackage - "package" keyword token. enterTypeApplication protected final void enterTypeApplication(ExpressionNodeBase collectionExpression) Called when the parser enters a type application expression. It validates the "collection expression" of the type application expression. It must be either a MemberAccessExpressionNode or an IdentifierNode. Parameters: collectionExpression - The expression node on the left-hand side of .< >. enterGroup protected final void enterGroup() Enter a "group" and increment the depth counter. leaveGroup protected final void leaveGroup() Leave a "group" and decrement the depth counter. enterClassDefinition protected final void enterClassDefinition(ASToken keywordClass) Check if class definition is allowed. Parameters: keywordClass - class keyword token. enterInterfaceDefinition protected final void enterInterfaceDefinition(ASToken keywordInterface) Check if interface definition is allowed. Parameters: keywordInterface - interface keyword token. leavePackage protected final void leavePackage() Decrement package depth counter. isGlobalContext protected final boolean isGlobalContext() A syntax tree is in a global context if it is nested by a program without crossing a block, or nested by the block of a package directive without crossing another block. Note that directive-level blocks are called "groups". Entering a group doesn't cause the parser to leave global context. Returns: True if the current context is global context. isFunctionClosure protected final boolean isFunctionClosure() Disambiguate between a function definition and a function closure. Returns: True if the next "function" keyword defines a closure. afterInnerSubstatement protected final void afterInnerSubstatement() Ignore missing semicolons in the following two cases: do x++ while (x<10); // after x++ if (x<10) x++ else x--; // after x++ recoverFromMetadataTag protected final void recoverFromMetadataTag(ContainerNode container, ArrayLiteralNode arrayLiteralNode) Recover from metadata parsing failure. Code model require error recovery logic for the following case: [ function hello():void {} The incomplete square bracket is expected to be matched as part of a metadata tag, and the following function definition is properly built. However, function objects in array literals are valid: var fs = [ function f1():void{}, function f2():void{} ]; In order to appease code hinting, the recovery logic will hoist the elements in the failed array literal into the parent node of the array literal node. Parameters: container - Parent node of array literal node. arrayLiteralNode - Array literal node, whose contents will be hoisted. isIncompleteMetadataTagOnDefinition protected final boolean isIncompleteMetadataTagOnDefinition() Determine if the parser should deploy an error trap for a typing-in-progress metadata tag on a definition item. For example: class T { [ public var name:String; [ public override function hello():void {} [ function process(); } The error trap is enabled when the "[" token is the only token on the current line, and the next token can start a definition item. xmlTagOpen protected final void xmlTagOpen(ASToken token) Called when a <foo token is encountered. Parameters: token - TOKEN_E4X_OPEN_TAG_START token. xmlTagOpenBinding protected final void xmlTagOpenBinding(ASToken token) Called when a < token is encountered. Parameters: token - HIDDEN_TOKEN_E4X token. xmlTagClose protected final void xmlTagClose(ASToken token) Called when a </foo token is encountered. Parameters: token - TOKEN_E4X_CLOSE_TAG_START token. xmlEmptyTagEnd protected final void xmlEmptyTagEnd(ASToken token) Called when a /> token is encountered. Parameters: token - TOKEN_E4X_EMPTY_TAG_END token. enterXMLLiteral protected final void enterXMLLiteral() Called when start parsing an XML literal. leaveXMLLiteral protected final void leaveXMLLiteral() Called when finish parsing an XML literal. This method validates the XML. isNextTokenPublicNamespace protected final boolean isNextTokenPublicNamespace() Syntactic predicate for CMP-335. Returns: True if the next token is "public" namespace token. isDefinitionEnabled protected final boolean isDefinitionEnabled(ContainerNode containerNode) Check if the next attribute definition is gated with a configuration condition variable. If it is, then return the evaluated result of the condition. Parameters: containerNode - parent node Returns: True if the attributed definition is enabled. file public final void file(ContainerNode c) throws antlr.RecognitionException, antlr.TokenStreamException Parses an ActionScript3 file and populate the FileNode. This method forces the parser to retry after fileLevelDirectives(ContainerNode) fails. Before retrying, the parser makes sure one and only one ExtraCharactersAfterEndOfProgramProblem is logged. Then, it discards the offending token and continue matching at "directive" level. I didn't write this as a regular ANTLR rule because the ANTLR-generated code wouldn't enter fileLevelDirectives(ContainerNode) if the lookahead is not one of the tokens in the "start set". Throws: antlr.RecognitionException antlr.TokenStreamException isParsingProjectConfigVariables public final boolean isParsingProjectConfigVariables() Returns: true when we are parsing project vars (like the command line)

Class ASParser

Nested Class Summary

Field Summary

Fields inherited from class antlr.Parser

Fields inherited from interface org.apache.flex.compiler.internal.parsing.as.ASTokenTypes

Constructor Summary

Method Summary

Methods inherited from class antlr.LLkParser

Methods inherited from class antlr.Parser

Methods inherited from class java.lang.Object

Field Detail

_tokenNames

_tokenSet_0

_tokenSet_1

_tokenSet_2

_tokenSet_3

_tokenSet_4

_tokenSet_5

_tokenSet_6

_tokenSet_7

_tokenSet_8

_tokenSet_9

_tokenSet_10

_tokenSet_11

_tokenSet_12

_tokenSet_13

_tokenSet_14

_tokenSet_15

_tokenSet_16

_tokenSet_17

_tokenSet_18

_tokenSet_19

EMPTY_CONFIGURATION

NO_END_TOKEN

buffer

currentAttributes

asDocDelegate

errorToken

allowEmbeds

insideClass

errors

deferFunctionBody

expressionMode

Constructor Detail

ASParser

ASParser

ASParser

ASParser

ASParser

ASParser

ASParser

Method Detail

fileLevelDirectives

directive

groupDirective

statement

attributedDefinition

asDocComment

importDirective

useNamespaceDirective

groupDirectiveWithConfigVariable

packageDirective

configNamespace

includeDirective

configConditionOfDefinition

attribute

definition

modifierAttribute

namespaceModifier

variableDefinition

functionDefinition

namespaceDefinition

classDefinition

interfaceDefinition

configCondition

breakOrContinueStatement

defaultXMLNamespaceStatement

gotoStatement

emptyStatement

labeledStatement