| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.adobe.ac.pmd.rules.core; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.NoSuchElementException; |
| import java.util.logging.Logger; |
| |
| import com.adobe.ac.pmd.IFlexViolation; |
| import com.adobe.ac.pmd.nodes.IAttribute; |
| import com.adobe.ac.pmd.nodes.IClass; |
| import com.adobe.ac.pmd.nodes.IConstant; |
| import com.adobe.ac.pmd.nodes.IFunction; |
| import com.adobe.ac.pmd.nodes.INode; |
| import com.adobe.ac.pmd.nodes.IPackage; |
| import com.adobe.ac.pmd.parser.IParserNode; |
| import com.adobe.ac.pmd.parser.NodeKind; |
| import com.adobe.ac.utils.StackTraceUtils; |
| |
| /** |
| * Abstract class for AST-based rule Extends this class if your rule is only |
| * detectable in an AS script block, which can be converted into an Abstract |
| * Syntax Tree. Then you will be able to either use the visitor pattern, or to |
| * iterate from the package node, in order to find your violation(s). |
| */ |
| public abstract class AbstractAstFlexRule extends AbstractFlexRule implements IFlexAstRule |
| { |
| /** |
| * |
| */ |
| protected enum FunctionType |
| { |
| GETTER, NORMAL, SETTER |
| } |
| |
| /** |
| * |
| */ |
| protected enum VariableOrConstant |
| { |
| CONSTANT, VARIABLE |
| } |
| |
| /** |
| * |
| */ |
| protected enum VariableScope |
| { |
| IN_CLASS, IN_FUNCTION |
| } |
| |
| private interface ExpressionVisitor |
| { |
| void visitExpression( final IParserNode ast ); |
| } |
| |
| private static final Logger LOGGER = Logger.getLogger( AbstractAstFlexRule.class.getName() ); |
| |
| /** |
| * @param functionNode |
| * @return |
| */ |
| /** |
| * @param functionNode |
| * @return |
| */ |
| protected static IParserNode getNameFromFunctionDeclaration( final IParserNode functionNode ) |
| { |
| IParserNode nameChild = null; |
| |
| for ( final IParserNode child : functionNode.getChildren() ) |
| { |
| if ( child.is( NodeKind.NAME ) ) |
| { |
| nameChild = child; |
| break; |
| } |
| } |
| return nameChild; |
| } |
| |
| /** |
| * @param fieldNode |
| * @return |
| */ |
| protected static IParserNode getTypeFromFieldDeclaration( final IParserNode fieldNode ) |
| { |
| return fieldNode.getChild( 0 ).getChild( 1 ); |
| } |
| |
| private final List< IFlexViolation > violations; |
| |
| /** |
| * |
| */ |
| public AbstractAstFlexRule() |
| { |
| super(); |
| |
| violations = new ArrayList< IFlexViolation >(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see |
| * com.adobe.ac.pmd.rules.core.AbstractFlexRule#isConcernedByTheCurrentFile |
| * () |
| */ |
| @Override |
| public boolean isConcernedByTheCurrentFile() |
| { |
| return true; |
| } |
| |
| /** |
| * @param function |
| * @return the added violation positioned on the given function node |
| */ |
| protected final IFlexViolation addViolation( final IFunction function ) |
| { |
| final IParserNode name = getNameFromFunctionDeclaration( function.getInternalNode() ); |
| |
| return addViolation( name, |
| name, |
| name.getStringValue() ); |
| } |
| |
| /** |
| * @param function |
| * @param messageToReplace |
| * @return |
| */ |
| protected final IFlexViolation addViolation( final IFunction function, |
| final String messageToReplace ) |
| { |
| final IParserNode name = getNameFromFunctionDeclaration( function.getInternalNode() ); |
| |
| return addViolation( name, |
| name, |
| messageToReplace ); |
| } |
| |
| /** |
| * @param violatingNode |
| * @return the added violation replacing the threshold value in the message |
| * if any. |
| */ |
| protected final IFlexViolation addViolation( final INode violatingNode ) |
| { |
| return addViolation( violatingNode.getInternalNode(), |
| violatingNode.getInternalNode() ); |
| } |
| |
| /** |
| * @param violatingNode |
| * @return the added violation replacing the threshold value in the message |
| * if any. |
| */ |
| protected final IFlexViolation addViolation( final INode violatingNode, |
| final String... messageToReplace ) |
| { |
| return addViolation( violatingNode.getInternalNode(), |
| violatingNode.getInternalNode(), |
| messageToReplace ); |
| } |
| |
| /** |
| * @param violatingNode |
| * @param endNode |
| * @return the added violation replacing the threshold value in the message |
| * if any. |
| */ |
| protected final IFlexViolation addViolation( final IParserNode violatingNode ) |
| { |
| return addViolation( violatingNode, |
| violatingNode ); |
| } |
| |
| /** |
| * @param beginningNode |
| * @param endNode |
| * @param messageToReplace |
| * @return the add violation replacing the {0} token by the specified message |
| */ |
| protected final IFlexViolation addViolation( final IParserNode beginningNode, |
| final IParserNode endNode, |
| final String... messageToReplace ) |
| { |
| if ( isAlreadyViolationAdded( beginningNode ) ) |
| { |
| return null; |
| } |
| final IFlexViolation violation = addViolation( ViolationPosition.create( beginningNode.getLine(), |
| endNode.getLine(), |
| beginningNode.getColumn(), |
| endNode.getColumn() ) ); |
| |
| for ( int i = 0; i < messageToReplace.length; i++ ) |
| { |
| violation.replacePlaceholderInMessage( messageToReplace[ i ], |
| i ); |
| } |
| |
| return violation; |
| } |
| |
| /** |
| * @param violatingNode |
| * @param endNode |
| * @param messageToReplace |
| * @return the add violation replacing the {0} token by the specified message |
| */ |
| protected final IFlexViolation addViolation( final IParserNode violatingNode, |
| final String... messageToReplace ) |
| { |
| return addViolation( violatingNode, |
| violatingNode, |
| messageToReplace ); |
| } |
| |
| /** |
| * @param violationPosition |
| * @return the added violation positioned at the given position |
| */ |
| protected final IFlexViolation addViolation( final ViolationPosition violationPosition ) |
| { |
| return addViolation( violations, |
| violationPosition ); |
| } |
| |
| /** |
| * find the violations list from the given class node |
| * |
| * @param classNode |
| */ |
| protected void findViolations( final IClass classNode ) |
| { |
| findViolationsFromAttributes( classNode.getAttributes() ); |
| findViolationsFromConstants( classNode.getConstants() ); |
| findViolations( classNode.getFunctions() ); |
| if ( classNode.getConstructor() != null ) |
| { |
| findViolationsFromConstructor( classNode.getConstructor() ); |
| } |
| } |
| |
| /** |
| * find violations in every function in a class |
| * |
| * @param function |
| */ |
| protected void findViolations( final IFunction function ) |
| { |
| } |
| |
| /** |
| * Override this method if you need to find violations from the package ( or |
| * any subsequent node like class or function) |
| * |
| * @param packageNode |
| */ |
| protected void findViolations( final IPackage packageNode ) |
| { |
| final IClass classNode = packageNode.getClassNode(); |
| |
| if ( classNode != null ) |
| { |
| findViolations( classNode ); |
| } |
| } |
| |
| /** |
| * find the violations list from the given functions list |
| * |
| * @param functions |
| */ |
| protected void findViolations( final List< IFunction > functions ) |
| { |
| for ( final IFunction function : functions ) |
| { |
| findViolations( function ); |
| } |
| } |
| |
| /** |
| * find the violations list from the given class variables list |
| * |
| * @param variables |
| */ |
| protected void findViolationsFromAttributes( final List< IAttribute > variables ) |
| { |
| } |
| |
| /** |
| * find the violations list from the given class constants list |
| * |
| * @param constants |
| */ |
| protected void findViolationsFromConstants( final List< IConstant > constants ) |
| { |
| } |
| |
| /** |
| * find the violations list from the given class constructor node |
| * |
| * @param constructor |
| */ |
| protected void findViolationsFromConstructor( final IFunction constructor ) |
| { |
| } |
| |
| /** |
| * Find violations in the current file |
| */ |
| @Override |
| protected final List< IFlexViolation > findViolationsInCurrentFile() |
| { |
| try |
| { |
| if ( getCurrentPackageNode() != null ) |
| { |
| visitCompilationUnit( getCurrentPackageNode().getInternalNode() ); |
| findViolations( getCurrentPackageNode() ); |
| } |
| } |
| catch ( final Exception e ) |
| { |
| LOGGER.warning( "on " |
| + getCurrentFile().getFilePath() ); |
| LOGGER.warning( StackTraceUtils.print( e ) ); |
| } |
| final List< IFlexViolation > copy = new ArrayList< IFlexViolation >( violations ); |
| |
| violations.clear(); |
| |
| return copy; |
| } |
| |
| /** |
| * @param statementNode |
| */ |
| protected void visitAs( final IParserNode statementNode ) |
| { |
| } |
| |
| /** |
| * @param catchNode |
| */ |
| protected void visitCatch( final IParserNode catchNode ) |
| { |
| visitNameTypeInit( catchNode.getChild( 0 ) ); |
| visitBlock( catchNode.getChild( 1 ) ); |
| } |
| |
| /** |
| * @param classNode |
| */ |
| protected void visitClass( final IParserNode classNode ) |
| { |
| IParserNode content = null; |
| for ( final IParserNode node : classNode.getChildren() ) |
| { |
| if ( node.is( NodeKind.CONTENT ) ) |
| { |
| content = node; |
| break; |
| } |
| } |
| visitClassContent( content ); |
| } |
| |
| /** |
| * Visit the condition of a if, while, ... |
| * |
| * @param condition |
| */ |
| protected void visitCondition( final IParserNode condition ) |
| { |
| visitExpression( condition ); |
| } |
| |
| /** |
| * @param doNode |
| */ |
| protected void visitDo( final IParserNode doNode ) |
| { |
| visitBlock( doNode.getChild( 0 ) ); |
| visitCondition( doNode.getChild( 1 ) ); |
| } |
| |
| /** |
| * @param ifNode |
| */ |
| protected void visitElse( final IParserNode ifNode ) |
| { |
| visitBlock( ifNode.getChild( 2 ) ); |
| } |
| |
| /** |
| * Visit empty statement |
| * |
| * @param statementNode |
| */ |
| protected void visitEmptyStatetement( final IParserNode statementNode ) |
| { |
| } |
| |
| /** |
| * @param finallyNode |
| */ |
| protected void visitFinally( final IParserNode finallyNode ) |
| { |
| if ( isNodeNavigable( finallyNode ) ) |
| { |
| visitBlock( finallyNode.getChild( 0 ) ); |
| } |
| } |
| |
| /** |
| * @param forNode |
| */ |
| protected void visitFor( final IParserNode forNode ) |
| { |
| visitBlock( forNode.getChild( 3 ) ); |
| } |
| |
| /** |
| * @param foreachNode |
| */ |
| protected void visitForEach( final IParserNode foreachNode ) |
| { |
| visitBlock( foreachNode.getChild( 2 ) ); |
| } |
| |
| /** |
| * @param functionNode |
| * @param type |
| */ |
| protected void visitFunction( final IParserNode functionNode, |
| final FunctionType type ) |
| { |
| final Iterator< IParserNode > iterator = functionNode.getChildren().iterator(); |
| IParserNode currentNode = iterator.next(); |
| |
| while ( currentNode.is( NodeKind.META_LIST ) |
| || currentNode.is( NodeKind.MOD_LIST ) || currentNode.is( NodeKind.AS_DOC ) |
| || currentNode.is( NodeKind.MULTI_LINE_COMMENT ) ) |
| { |
| currentNode = iterator.next(); |
| } |
| currentNode = iterator.next(); |
| visitParameters( currentNode ); |
| currentNode = iterator.next(); |
| visitFunctionReturnType( currentNode ); |
| try |
| { |
| // Intrinsic functions in AS2 |
| currentNode = iterator.next(); |
| visitFunctionBody( currentNode ); |
| } |
| catch ( final NoSuchElementException e ) |
| { |
| } |
| } |
| |
| /** |
| * @param functionReturnTypeNode |
| */ |
| protected void visitFunctionReturnType( final IParserNode functionReturnTypeNode ) |
| { |
| visitBlock( functionReturnTypeNode ); |
| } |
| |
| /** |
| * @param ifNode |
| */ |
| protected void visitIf( final IParserNode ifNode ) |
| { |
| visitCondition( ifNode.getChild( 0 ) ); |
| visitThen( ifNode ); |
| if ( ifNode.numChildren() == 3 ) |
| { |
| visitElse( ifNode ); |
| } |
| } |
| |
| /** |
| * @param interfaceNode |
| */ |
| protected void visitInterface( final IParserNode interfaceNode ) |
| { |
| } |
| |
| /** |
| * @param methodCallNode |
| */ |
| protected void visitMethodCall( final IParserNode methodCallNode ) |
| { |
| final Iterator< IParserNode > iterator = methodCallNode.getChildren().iterator(); |
| visitExpression( iterator.next() ); |
| do |
| { |
| visitExpressionList( iterator.next() ); |
| } |
| while ( iterator.hasNext() ); |
| } |
| |
| /** |
| * @param newExpression |
| */ |
| protected void visitNewExpression( final IParserNode newExpression ) |
| { |
| visitExpression( newExpression.getChild( 0 ) ); |
| visitExpressionList( newExpression.getChild( 1 ) ); |
| } |
| |
| protected void visitOperator( final IParserNode statementNode ) |
| { |
| } |
| |
| /** |
| * @param functionParametersNode |
| */ |
| protected void visitParameters( final IParserNode functionParametersNode ) |
| { |
| if ( isNodeNavigable( functionParametersNode ) ) |
| { |
| for ( final IParserNode node2 : functionParametersNode.getChildren() ) |
| { |
| visitNameTypeInit( node2.getChild( 0 ) ); |
| } |
| } |
| } |
| |
| protected void visitRelationalExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.RELATION, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitShiftExpression( ast ); |
| } |
| } ); |
| } |
| |
| /** |
| * @param ast |
| */ |
| protected void visitReturn( final IParserNode ast ) |
| { |
| if ( isNodeNavigable( ast ) ) |
| { |
| visitExpression( ast.getChild( 0 ) ); |
| } |
| } |
| |
| /** |
| * @param statementNode |
| */ |
| protected void visitStatement( final IParserNode statementNode ) |
| { |
| switch ( statementNode.getId() ) |
| { |
| case OP: |
| visitOperator( statementNode ); |
| break; |
| case AS: |
| visitAs( statementNode ); |
| break; |
| case RETURN: |
| visitReturn( statementNode ); |
| break; |
| case IF: |
| visitIf( statementNode ); |
| break; |
| case FOR: |
| visitFor( statementNode ); |
| break; |
| case FOREACH: |
| visitForEach( statementNode ); |
| break; |
| case DO: |
| visitDo( statementNode ); |
| break; |
| case WHILE: |
| visitWhile( statementNode ); |
| break; |
| case SWITCH: |
| visitSwitch( statementNode ); |
| break; |
| case TRY: |
| visitTry( statementNode ); |
| break; |
| case CATCH: |
| visitCatch( statementNode ); |
| break; |
| case FINALLY: |
| visitFinally( statementNode ); |
| break; |
| case STMT_EMPTY: |
| visitEmptyStatetement( statementNode ); |
| break; |
| case LEFT_CURLY_BRACKET: |
| visitBlock( statementNode ); |
| break; |
| default: |
| visitExpressionList( statementNode ); |
| } |
| } |
| |
| /** |
| * @param switchNode |
| */ |
| protected void visitSwitch( final IParserNode switchNode ) |
| { |
| final Iterator< IParserNode > iterator = switchNode.getChildren().iterator(); |
| |
| visitExpression( iterator.next() ); |
| |
| final IParserNode cases = iterator.next(); |
| |
| for ( final IParserNode caseNode : cases.getChildren() ) |
| { |
| final IParserNode child = caseNode.getChild( 0 ); |
| |
| if ( child.is( NodeKind.DEFAULT ) ) |
| { |
| visitSwitchDefaultCase( caseNode.getChild( 1 ) ); |
| } |
| else |
| { |
| visitSwitchCase( caseNode.getChild( 1 ) ); |
| visitExpression( child ); |
| } |
| } |
| } |
| |
| /** |
| * @param switchCaseNode |
| */ |
| protected void visitSwitchCase( final IParserNode switchCaseNode ) |
| { |
| visitBlock( switchCaseNode ); |
| } |
| |
| /** |
| * @param defaultCaseNode |
| */ |
| protected void visitSwitchDefaultCase( final IParserNode defaultCaseNode ) |
| { |
| visitBlock( defaultCaseNode ); |
| } |
| |
| /** |
| * @param ifNode |
| */ |
| protected void visitThen( final IParserNode ifNode ) |
| { |
| visitBlock( ifNode.getChild( 1 ) ); |
| } |
| |
| /** |
| * @param ast |
| */ |
| protected void visitTry( final IParserNode ast ) |
| { |
| visitBlock( ast.getChild( 0 ) ); |
| } |
| |
| /** |
| * @param node |
| */ |
| protected void visitVariableInitialization( final IParserNode node ) |
| { |
| visitExpression( node ); |
| } |
| |
| /** |
| * @param variableNode |
| * @param varOrConst |
| * @param scope |
| */ |
| protected void visitVarOrConstList( final IParserNode variableNode, |
| final VariableOrConstant varOrConst, |
| final VariableScope scope ) |
| { |
| final Iterator< IParserNode > iterator = variableNode.getChildren().iterator(); |
| |
| IParserNode node = iterator.next(); |
| while ( node.is( NodeKind.META_LIST ) |
| || node.is( NodeKind.MOD_LIST ) ) |
| { |
| node = iterator.next(); |
| } |
| while ( node != null ) |
| { |
| visitNameTypeInit( node ); |
| node = iterator.hasNext() ? iterator.next() |
| : null; |
| } |
| } |
| |
| /** |
| * @param whileNode |
| */ |
| protected void visitWhile( final IParserNode whileNode ) |
| { |
| visitCondition( whileNode.getChild( 0 ) ); |
| visitBlock( whileNode.getChild( 1 ) ); |
| } |
| |
| private boolean isAlreadyViolationAdded( final IParserNode nodeToBeAdded ) |
| { |
| for ( final IFlexViolation violation : violations ) |
| { |
| if ( violation.getBeginLine() == nodeToBeAdded.getLine() |
| && violation.getBeginColumn() == nodeToBeAdded.getColumn() ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean isNodeNavigable( final IParserNode node ) |
| { |
| return node != null |
| && node.numChildren() != 0; |
| } |
| |
| private void visitAdditiveExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.ADD, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitMultiplicativeExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitAndExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.AND, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitBitwiseOrExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitArrayAccessor( final IParserNode ast ) |
| { |
| final Iterator< IParserNode > iterator = ast.getChildren().iterator(); |
| visitExpression( iterator.next() ); |
| do |
| { |
| visitExpression( iterator.next() ); |
| } |
| while ( iterator.hasNext() ); |
| } |
| |
| private void visitBitwiseAndExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.B_AND, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitEqualityExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitBitwiseOrExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.B_OR, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitBitwiseXorExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitBitwiseXorExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.B_XOR, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitBitwiseAndExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitBlock( final IParserNode ast ) |
| { |
| if ( isNodeNavigable( ast ) ) |
| { |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| visitStatement( node ); |
| } |
| } |
| else if ( ast != null ) |
| { |
| visitStatement( ast ); |
| } |
| } |
| |
| private void visitClassContent( final IParserNode ast ) |
| { |
| if ( isNodeNavigable( ast ) ) |
| { |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| if ( node.is( NodeKind.VAR_LIST ) ) |
| { |
| visitVarOrConstList( node, |
| VariableOrConstant.VARIABLE, |
| VariableScope.IN_CLASS ); |
| } |
| else if ( node.is( NodeKind.CONST_LIST ) ) |
| { |
| visitVarOrConstList( node, |
| VariableOrConstant.CONSTANT, |
| VariableScope.IN_CLASS ); |
| } |
| } |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| if ( node.is( NodeKind.FUNCTION ) ) |
| { |
| visitFunction( node, |
| FunctionType.NORMAL ); |
| } |
| else if ( node.is( NodeKind.SET ) ) |
| { |
| visitFunction( node, |
| FunctionType.SETTER ); |
| } |
| else if ( node.is( NodeKind.GET ) ) |
| { |
| visitFunction( node, |
| FunctionType.GETTER ); |
| } |
| } |
| } |
| } |
| |
| private void visitCompilationUnit( final IParserNode ast ) |
| { |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| if ( node.is( NodeKind.PACKAGE ) |
| && node.numChildren() >= 2 ) |
| { |
| visitPackageContent( node.getChild( 1 ) ); |
| } |
| if ( !node.is( NodeKind.PACKAGE ) |
| && node.numChildren() > 0 ) |
| { |
| visitPackageContent( node ); |
| } |
| } |
| } |
| |
| private void visitConditionalExpression( final IParserNode ast ) |
| { |
| if ( ast != null ) |
| { |
| if ( ast.is( NodeKind.CONDITIONAL ) ) |
| { |
| final Iterator< IParserNode > iterator = ast.getChildren().iterator(); |
| final IParserNode node = iterator.next(); |
| |
| visitOrExpression( node ); |
| |
| while ( iterator.hasNext() ) |
| { |
| visitExpression( iterator.next() ); |
| visitExpression( iterator.next() ); |
| } |
| } |
| else |
| { |
| visitOrExpression( ast ); |
| } |
| } |
| } |
| |
| private void visitEqualityExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.EQUALITY, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitRelationalExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.ASSIGN, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitConditionalExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitExpression( final IParserNode ast, |
| final NodeKind kind, |
| final ExpressionVisitor visitor ) |
| { |
| if ( ast.is( kind ) ) |
| { |
| final Iterator< IParserNode > iterator = ast.getChildren().iterator(); |
| final IParserNode node = iterator.next(); |
| |
| visitor.visitExpression( node ); |
| |
| while ( iterator.hasNext() ) |
| { |
| iterator.next(); |
| visitor.visitExpression( iterator.next() ); |
| } |
| } |
| else |
| { |
| visitor.visitExpression( ast ); |
| } |
| } |
| |
| private void visitExpressionList( final IParserNode ast ) |
| { |
| if ( isNodeNavigable( ast ) ) |
| { |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| visitExpression( node ); |
| } |
| } |
| } |
| |
| private void visitFunctionBody( final IParserNode node ) |
| { |
| visitBlock( node ); |
| } |
| |
| private void visitMultiplicativeExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.MULTIPLICATION, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitUnaryExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitNameTypeInit( final IParserNode ast ) |
| { |
| if ( ast != null |
| && ast.numChildren() != 0 ) |
| { |
| final Iterator< IParserNode > iterator = ast.getChildren().iterator(); |
| IParserNode node; |
| |
| iterator.next(); |
| iterator.next(); |
| |
| if ( iterator.hasNext() ) |
| { |
| node = iterator.next(); |
| visitVariableInitialization( node ); |
| } |
| } |
| } |
| |
| private void visitObjectInitialization( final IParserNode ast ) |
| { |
| if ( isNodeNavigable( ast ) ) |
| { |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| visitExpression( node.getChild( 1 ) ); |
| } |
| } |
| } |
| |
| private void visitOrExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.OR, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitAndExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitPackageContent( final IParserNode ast ) |
| { |
| if ( isNodeNavigable( ast ) ) |
| { |
| for ( final IParserNode node : ast.getChildren() ) |
| { |
| if ( node.is( NodeKind.CLASS ) ) |
| { |
| visitClass( node ); |
| } |
| else if ( node.is( NodeKind.INTERFACE ) ) |
| { |
| visitInterface( node ); |
| } |
| } |
| } |
| } |
| |
| private void visitPrimaryExpression( final IParserNode ast ) |
| { |
| if ( ast.is( NodeKind.NEW ) ) |
| { |
| visitNewExpression( ast ); |
| } |
| else if ( ast.numChildren() != 0 |
| && ast.is( NodeKind.ARRAY ) ) |
| { |
| visitExpressionList( ast ); |
| } |
| else if ( ast.is( NodeKind.OBJECT ) ) |
| { |
| visitObjectInitialization( ast ); |
| } |
| else if ( ast.is( NodeKind.E4X_ATTR ) ) |
| { |
| final IParserNode node = ast.getChild( 0 ); |
| |
| if ( !node.is( NodeKind.NAME ) |
| && !node.is( NodeKind.STAR ) ) |
| { |
| visitExpression( node ); |
| } |
| } |
| else |
| { |
| visitExpressionList( ast ); |
| } |
| } |
| |
| private void visitShiftExpression( final IParserNode ast ) |
| { |
| visitExpression( ast, |
| NodeKind.SHIFT, |
| new ExpressionVisitor() |
| { |
| public void visitExpression( final IParserNode ast ) |
| { |
| visitAdditiveExpression( ast ); |
| } |
| } ); |
| } |
| |
| private void visitUnaryExpression( final IParserNode ast ) |
| { |
| switch ( ast.getId() ) |
| { |
| case PRE_INC: |
| case PRE_DEC: |
| case MINUS: |
| case PLUS: |
| visitUnaryExpression( ast.getChild( 0 ) ); |
| break; |
| default: |
| visitUnaryExpressionNotPlusMinus( ast ); |
| } |
| } |
| |
| private void visitUnaryExpressionNotPlusMinus( final IParserNode ast ) |
| { |
| switch ( ast.getId() ) |
| { |
| case DELETE: |
| case VOID: |
| case TYPEOF: |
| case NOT: |
| case B_NOT: |
| visitExpression( ast.getChild( 0 ) ); |
| break; |
| default: |
| visitUnaryPostfixExpression( ast ); |
| } |
| } |
| |
| private void visitUnaryPostfixExpression( final IParserNode ast ) |
| { |
| switch ( ast.getId() ) |
| { |
| case ARRAY_ACCESSOR: |
| visitArrayAccessor( ast ); |
| break; |
| case DOT: |
| case E4X_FILTER: |
| visitExpression( ast.getChild( 0 ) ); |
| visitExpression( ast.getChild( 1 ) ); |
| break; |
| case POST_INC: |
| case POST_DEC: |
| visitPrimaryExpression( ast.getChild( 0 ) ); |
| break; |
| case CALL: |
| visitMethodCall( ast ); |
| break; |
| case E4X_STAR: |
| visitExpression( ast.getChild( 0 ) ); |
| break; |
| default: |
| visitPrimaryExpression( ast ); |
| break; |
| } |
| } |
| } |
