traversalhelper.java

大名鼎鼎的java动态脚本语言。已经通过了sun的认证

/**
 *
 * Copyright 2005 Jeremy Rayner
 *
 * Licensed 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 org.codehaus.groovy.antlr.treewalker;

import java.util.List;
import java.util.ArrayList;
import java.util.Stack;

import org.codehaus.groovy.antlr.GroovySourceAST;
import org.codehaus.groovy.antlr.AntlrASTProcessor;
import org.codehaus.groovy.antlr.parser.GroovyTokenTypes;

import antlr.collections.AST;

/**                                                  
 * Helper Class for Antlr AST traversal and visitation.
 *
 * @author <a href="mailto:[e-mail]">Jeremy Rayner</a>
 * @version $Revision: 1.8 $
 */

public abstract class TraversalHelper implements AntlrASTProcessor {
    protected List unvisitedNodes;
    private Visitor v;

    public TraversalHelper(Visitor visitor) {
        this.unvisitedNodes = new ArrayList();
        this.v = visitor;
    }

    protected void setUp(GroovySourceAST ast) {
        v.setUp();
    }
    protected void tearDown(GroovySourceAST ast) {
        v.tearDown();
    }

    protected void push(GroovySourceAST ast) {
        v.push(ast);
    }
    protected GroovySourceAST pop() {
        return v.pop();
    }

    protected void visitNode(GroovySourceAST ast, int n) {
        if (ast != null) {
            switch (ast.getType()) {
                case GroovyTokenTypes.ABSTRACT                      :   v.visitAbstract(ast,n);                     break;
                case GroovyTokenTypes.ANNOTATION                    :   v.visitAnnotation(ast,n);                   break;
                case GroovyTokenTypes.ANNOTATIONS                   :   v.visitAnnotations(ast,n);                  break;
                case GroovyTokenTypes.ANNOTATION_ARRAY_INIT         :   v.visitAnnotationArrayInit(ast,n);          break;
                case GroovyTokenTypes.ANNOTATION_DEF                :   v.visitAnnotationDef(ast,n);                break;
                case GroovyTokenTypes.ANNOTATION_FIELD_DEF          :   v.visitAnnotationFieldDef(ast,n);           break;
                case GroovyTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR  :   v.visitAnnotationMemberValuePair(ast,n);    break;
                case GroovyTokenTypes.ARRAY_DECLARATOR              :   v.visitArrayDeclarator(ast,n);              break;
                case GroovyTokenTypes.ASSIGN                        :   v.visitAssign(ast,n);                       break;
                case GroovyTokenTypes.AT                            :   v.visitAt(ast,n);                           break;
                case GroovyTokenTypes.BAND                          :   v.visitBand(ast,n);                         break;
                case GroovyTokenTypes.BAND_ASSIGN                   :   v.visitBandAssign(ast,n);                   break;
                case GroovyTokenTypes.BIG_SUFFIX                    :   v.visitBigSuffix(ast,n);                    break;
                case GroovyTokenTypes.BLOCK                         :   v.visitBlock(ast,n);                        break;
                case GroovyTokenTypes.BNOT                          :   v.visitBnot(ast,n);                         break;
                case GroovyTokenTypes.BOR                           :   v.visitBor(ast,n);                          break;
                case GroovyTokenTypes.BOR_ASSIGN                    :   v.visitBorAssign(ast,n);                    break;
                case GroovyTokenTypes.BSR                           :   v.visitBsr(ast,n);                          break;
                case GroovyTokenTypes.BSR_ASSIGN                    :   v.visitBsrAssign(ast,n);                    break;
                case GroovyTokenTypes.BXOR                          :   v.visitBxor(ast,n);                         break;
                case GroovyTokenTypes.BXOR_ASSIGN                   :   v.visitBxorAssign(ast,n);                   break;
                case GroovyTokenTypes.CASE_GROUP                    :   v.visitCaseGroup(ast,n);                    break;
                case GroovyTokenTypes.CLASS_DEF                     :   v.visitClassDef(ast,n);                     break;
                case GroovyTokenTypes.CLOSED_BLOCK                  :   v.visitClosedBlock(ast,n);                  break;
                case GroovyTokenTypes.CLOSURE_OP                    :   v.visitClosureOp(ast,n);                    break;
                case GroovyTokenTypes.COLON                         :   v.visitColon(ast,n);                        break;
                case GroovyTokenTypes.COMMA                         :   v.visitComma(ast,n);                        break;
                case GroovyTokenTypes.COMPARE_TO                    :   v.visitCompareTo(ast,n);                    break;
                case GroovyTokenTypes.CTOR_CALL                     :   v.visitCtorCall(ast,n);                     break;
                case GroovyTokenTypes.CTOR_IDENT                    :   v.visitCtorIdent(ast,n);                    break;
                case GroovyTokenTypes.DEC                           :   v.visitDec(ast,n);                          break;
                case GroovyTokenTypes.DIGIT                         :   v.visitDigit(ast,n);                        break;
                case GroovyTokenTypes.DIV                           :   v.visitDiv(ast,n);                          break;
                case GroovyTokenTypes.DIV_ASSIGN                    :   v.visitDivAssign(ast,n);                    break;
                case GroovyTokenTypes.DOLLAR                        :   v.visitDollar(ast,n);                       break;
                case GroovyTokenTypes.DOT                           :   v.visitDot(ast,n);                          break;
                case GroovyTokenTypes.DYNAMIC_MEMBER                :   v.visitDynamicMember(ast,n);                break;
                case GroovyTokenTypes.ELIST                         :   v.visitElist(ast,n);                        break;
                case GroovyTokenTypes.EMPTY_STAT                    :   v.visitEmptyStat(ast,n);                    break;
                case GroovyTokenTypes.ENUM_CONSTANT_DEF             :   v.visitEnumConstantDef(ast,n);              break;
                case GroovyTokenTypes.ENUM_DEF                      :   v.visitEnumDef(ast,n);                      break;
                case GroovyTokenTypes.EOF                           :   v.visitEof(ast,n);                          break;
                case GroovyTokenTypes.EQUAL                         :   v.visitEqual(ast,n);                        break;
                case GroovyTokenTypes.ESC                           :   v.visitEsc(ast,n);                          break;
                case GroovyTokenTypes.EXPONENT                      :   v.visitExponent(ast,n);                     break;
                case GroovyTokenTypes.EXPR                          :   v.visitExpr(ast,n);                         break;
                case GroovyTokenTypes.EXTENDS_CLAUSE                :   v.visitExtendsClause(ast,n);                break;
                case GroovyTokenTypes.FINAL                         :   v.visitFinal(ast,n);                        break;
                case GroovyTokenTypes.FLOAT_SUFFIX                  :   v.visitFloatSuffix(ast,n);                  break;
                case GroovyTokenTypes.FOR_CONDITION                 :   v.visitForCondition(ast,n);                 break;
                case GroovyTokenTypes.FOR_EACH_CLAUSE               :   v.visitForEachClause(ast,n);                break;
                case GroovyTokenTypes.FOR_INIT                      :   v.visitForInit(ast,n);                      break;
                case GroovyTokenTypes.FOR_IN_ITERABLE               :   v.visitForInIterable(ast,n);                break;
                case GroovyTokenTypes.FOR_ITERATOR                  :   v.visitForIterator(ast,n);                  break;
                case GroovyTokenTypes.GE                            :   v.visitGe(ast,n);                           break;
                case GroovyTokenTypes.GT                            :   v.visitGt(ast,n);                           break;
                case GroovyTokenTypes.HEX_DIGIT                     :   v.visitHexDigit(ast,n);                     break;
                case GroovyTokenTypes.IDENT                         :   v.visitIdent(ast,n);                        break;
                case GroovyTokenTypes.IMPLEMENTS_CLAUSE             :   v.visitImplementsClause(ast,n);             break;
                case GroovyTokenTypes.IMPLICIT_PARAMETERS           :   v.visitImplicitParameters(ast,n);           break;
                case GroovyTokenTypes.IMPORT                        :   v.visitImport(ast,n);                       break;
                case GroovyTokenTypes.INC                           :   v.visitInc(ast,n);                          break;
                case GroovyTokenTypes.INDEX_OP                      :   v.visitIndexOp(ast,n);                      break;
                case GroovyTokenTypes.INSTANCE_INIT                 :   v.visitInstanceInit(ast,n);                 break;
                case GroovyTokenTypes.INTERFACE_DEF                 :   v.visitInterfaceDef(ast,n);                 break;
                case GroovyTokenTypes.LABELED_ARG                   :   v.visitLabeledArg(ast,n);                   break;
                case GroovyTokenTypes.LABELED_STAT                  :   v.visitLabeledStat(ast,n);                  break;
                case GroovyTokenTypes.LAND                          :   v.visitLand(ast,n);                         break;
                case GroovyTokenTypes.LBRACK                        :   v.visitLbrack(ast,n);                       break;
                case GroovyTokenTypes.LCURLY                        :   v.visitLcurly(ast,n);                       break;
                case GroovyTokenTypes.LE                            :   v.visitLe(ast,n);                           break;
                case GroovyTokenTypes.LETTER                        :   v.visitLetter(ast,n);                       break;
                case GroovyTokenTypes.LIST_CONSTRUCTOR              :   v.visitListConstructor(ast,n);              break;
                case GroovyTokenTypes.LITERAL_any                   :   v.visitLiteralAny(ast,n);                   break;
                case GroovyTokenTypes.LITERAL_as                    :   v.visitLiteralAs(ast,n);                    break;
                case GroovyTokenTypes.LITERAL_assert                :   v.visitLiteralAssert(ast,n);                break;
                case GroovyTokenTypes.LITERAL_boolean               :   v.visitLiteralBoolean(ast,n);               break;
                case GroovyTokenTypes.LITERAL_break                 :   v.visitLiteralBreak(ast,n);                 break;
                case GroovyTokenTypes.LITERAL_byte                  :   v.visitLiteralByte(ast,n);                  break;
                case GroovyTokenTypes.LITERAL_case                  :   v.visitLiteralCase(ast,n);                  break;
                case GroovyTokenTypes.LITERAL_catch                 :   v.visitLiteralCatch(ast,n);                 break;
                case GroovyTokenTypes.LITERAL_char                  :   v.visitLiteralChar(ast,n);                  break;
                case GroovyTokenTypes.LITERAL_class                 :   v.visitLiteralClass(ast,n);                 break;
                case GroovyTokenTypes.LITERAL_continue              :   v.visitLiteralContinue(ast,n);              break;
                case GroovyTokenTypes.LITERAL_def                   :   v.visitLiteralDef(ast,n);                   break;
                case GroovyTokenTypes.LITERAL_default               :   v.visitLiteralDefault(ast,n);               break;
                case GroovyTokenTypes.LITERAL_double                :   v.visitLiteralDouble(ast,n);                break;
                case GroovyTokenTypes.LITERAL_else                  :   v.visitLiteralElse(ast,n);                  break;
                case GroovyTokenTypes.LITERAL_enum                  :   v.visitLiteralEnum(ast,n);                  break;
                case GroovyTokenTypes.LITERAL_extends               :   v.visitLiteralExtends(ast,n);               break;
                case GroovyTokenTypes.LITERAL_false                 :   v.visitLiteralFalse(ast,n);                 break;
                case GroovyTokenTypes.LITERAL_finally               :   v.visitLiteralFinally(ast,n);               break;
                case GroovyTokenTypes.LITERAL_float                 :   v.visitLiteralFloat(ast,n);                 break;
                case GroovyTokenTypes.LITERAL_for                   :   v.visitLiteralFor(ast,n);                   break;
                case GroovyTokenTypes.LITERAL_if                    :   v.visitLiteralIf(ast,n);                    break;
                case GroovyTokenTypes.LITERAL_implements            :   v.visitLiteralImplements(ast,n);            break;
                case GroovyTokenTypes.LITERAL_import                :   v.visitLiteralImport(ast,n);                break;
                case GroovyTokenTypes.LITERAL_in                    :   v.visitLiteralIn(ast,n);                    break;