/* * Janino - An embedded Java[TM] compiler * * Copyright (c) 2001-2010, Arno Unkrig * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the * following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the * following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the * following disclaimer in the documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ package org.codehaus.janino; /** Basis for the "visitor" pattern as described in "Gamma, Helm, Johnson, Vlissides: Design Patterns". */ public class Visitor { /** * The union of {@link ImportVisitor}, {@link TypeDeclarationVisitor}, {@link TypeBodyDeclarationVisitor} and * {@link AtomVisitor}. */ public interface ComprehensiveVisitor extends ImportVisitor, TypeDeclarationVisitor, TypeBodyDeclarationVisitor, BlockStatementVisitor, AtomVisitor, ElementValueVisitor { // SUPPRESS CHECKSTYLE WrapAndIndent } /** The visitor for all kinds of {@link Java.CompilationUnit.ImportDeclaration}s. */ public interface ImportVisitor { /** Invoked by {@link Java.CompilationUnit.SingleTypeImportDeclaration#accept(Visitor.ImportVisitor)} */ void visitSingleTypeImportDeclaration(Java.CompilationUnit.SingleTypeImportDeclaration stid); /** Invoked by {@link Java.CompilationUnit.TypeImportOnDemandDeclaration#accept(Visitor.ImportVisitor)} */ void visitTypeImportOnDemandDeclaration(Java.CompilationUnit.TypeImportOnDemandDeclaration tiodd); /** Invoked by {@link Java.CompilationUnit.SingleStaticImportDeclaration#accept(Visitor.ImportVisitor)} */ void visitSingleStaticImportDeclaration(Java.CompilationUnit.SingleStaticImportDeclaration ssid); /** Invoked by {@link Java.CompilationUnit.StaticImportOnDemandDeclaration#accept(Visitor.ImportVisitor)} */ void visitStaticImportOnDemandDeclaration(Java.CompilationUnit.StaticImportOnDemandDeclaration siodd); } /** The visitor for all kinds of {@link Java.TypeDeclaration}s. */ public interface TypeDeclarationVisitor { /** Invoked by {@link Java.AnonymousClassDeclaration#accept(Visitor.TypeDeclarationVisitor)} */ void visitAnonymousClassDeclaration(Java.AnonymousClassDeclaration acd); /** Invoked by {@link Java.LocalClassDeclaration#accept(Visitor.TypeDeclarationVisitor)} */ void visitLocalClassDeclaration(Java.LocalClassDeclaration lcd); /** Invoked by {@link Java.PackageMemberClassDeclaration#accept(Visitor.TypeDeclarationVisitor)} */ void visitPackageMemberClassDeclaration(Java.PackageMemberClassDeclaration pmcd); /** Invoked by {@link Java.MemberInterfaceDeclaration#accept(Visitor.TypeDeclarationVisitor)} */ void visitMemberInterfaceDeclaration(Java.MemberInterfaceDeclaration mid); /** Invoked by {@link Java.PackageMemberInterfaceDeclaration#accept(Visitor.TypeDeclarationVisitor)} */ void visitPackageMemberInterfaceDeclaration(Java.PackageMemberInterfaceDeclaration pmid); /** Invoked by {@link Java.MemberClassDeclaration#accept(Visitor.TypeDeclarationVisitor)} */ void visitMemberClassDeclaration(Java.MemberClassDeclaration mcd); } /** The visitor for all kinds of {@link Java.FunctionDeclarator}s. */ public interface FunctionDeclaratorVisitor { /** Invoked by {@link Java.ConstructorDeclarator#accept(Visitor.TypeBodyDeclarationVisitor)} */ void visitConstructorDeclarator(Java.ConstructorDeclarator cd); /** Invoked by {@link Java.MethodDeclarator#accept(Visitor.TypeBodyDeclarationVisitor)} */ void visitMethodDeclarator(Java.MethodDeclarator md); } /** * The visitor for all kinds of {@link Java.TypeBodyDeclaration}s (declarations that may appear in the body of a * type declaration). */ public interface TypeBodyDeclarationVisitor extends FunctionDeclaratorVisitor { /** Invoked by {@link Java.MemberInterfaceDeclaration#accept(Visitor.TypeBodyDeclarationVisitor)} */ void visitMemberInterfaceDeclaration(Java.MemberInterfaceDeclaration mid); /** Invoked by {@link Java.MemberClassDeclaration#accept(Visitor.TypeBodyDeclarationVisitor)} */ void visitMemberClassDeclaration(Java.MemberClassDeclaration mcd); /** Invoked by {@link Java.Initializer#accept(Visitor.TypeBodyDeclarationVisitor)} */ void visitInitializer(Java.Initializer i); /** Invoked by {@link Java.FieldDeclaration#accept(Visitor.TypeBodyDeclarationVisitor)} */ void visitFieldDeclaration(Java.FieldDeclaration fd); } /** The visitor for all kinds of {@link Java.BlockStatement}s (statements that may appear with a block). */ public interface BlockStatementVisitor { /** Invoked by {@link Java.Initializer#accept(Visitor.BlockStatementVisitor)} */ void visitInitializer(Java.Initializer i); /** Invoked by {@link Java.FieldDeclaration#accept(Visitor.BlockStatementVisitor)} */ void visitFieldDeclaration(Java.FieldDeclaration fd); /** Invoked by {@link Java.LabeledStatement#accept(Visitor.BlockStatementVisitor)} */ void visitLabeledStatement(Java.LabeledStatement ls); /** Invoked by {@link Java.Block#accept(Visitor.BlockStatementVisitor)} */ void visitBlock(Java.Block b); /** Invoked by {@link Java.ExpressionStatement#accept(Visitor.BlockStatementVisitor)} */ void visitExpressionStatement(Java.ExpressionStatement es); /** Invoked by {@link Java.IfStatement#accept(Visitor.BlockStatementVisitor)} */ void visitIfStatement(Java.IfStatement is); /** Invoked by {@link Java.ForStatement#accept(Visitor.BlockStatementVisitor)} */ void visitForStatement(Java.ForStatement fs); /** Invoked by {@link Java.ForEachStatement#accept(Visitor.BlockStatementVisitor)} */ void visitForEachStatement(Java.ForEachStatement forEachStatement); /** Invoked by {@link Java.WhileStatement#accept(Visitor.BlockStatementVisitor)} */ void visitWhileStatement(Java.WhileStatement ws); /** Invoked by {@link Java.TryStatement#accept(Visitor.BlockStatementVisitor)} */ void visitTryStatement(Java.TryStatement ts); /** Invoked by {@link Java.SwitchStatement#accept(Visitor.BlockStatementVisitor)} */ void visitSwitchStatement(Java.SwitchStatement ss); /** Invoked by {@link Java.SynchronizedStatement#accept(Visitor.BlockStatementVisitor)} */ void visitSynchronizedStatement(Java.SynchronizedStatement ss); /** Invoked by {@link Java.DoStatement#accept(Visitor.BlockStatementVisitor)} */ void visitDoStatement(Java.DoStatement ds); /** Invoked by {@link Java.LocalVariableDeclarationStatement#accept(Visitor.BlockStatementVisitor)} */ void visitLocalVariableDeclarationStatement(Java.LocalVariableDeclarationStatement lvds); /** Invoked by {@link Java.ReturnStatement#accept(Visitor.BlockStatementVisitor)} */ void visitReturnStatement(Java.ReturnStatement rs); /** Invoked by {@link Java.ThrowStatement#accept(Visitor.BlockStatementVisitor)} */ void visitThrowStatement(Java.ThrowStatement ts); /** Invoked by {@link Java.BreakStatement#accept(Visitor.BlockStatementVisitor)} */ void visitBreakStatement(Java.BreakStatement bs); /** Invoked by {@link Java.ContinueStatement#accept(Visitor.BlockStatementVisitor)} */ void visitContinueStatement(Java.ContinueStatement cs); /** Invoked by {@link Java.AssertStatement#accept(Visitor.BlockStatementVisitor)} */ void visitAssertStatement(Java.AssertStatement as); /** Invoked by {@link Java.EmptyStatement#accept(Visitor.BlockStatementVisitor)} */ void visitEmptyStatement(Java.EmptyStatement es); /** Invoked by {@link Java.LocalClassDeclarationStatement#accept(Visitor.BlockStatementVisitor)} */ void visitLocalClassDeclarationStatement(Java.LocalClassDeclarationStatement lcds); /** Invoked by {@link Java.AlternateConstructorInvocation#accept(Visitor.BlockStatementVisitor)} */ void visitAlternateConstructorInvocation(Java.AlternateConstructorInvocation aci); /** Invoked by {@link Java.SuperConstructorInvocation#accept(Visitor.BlockStatementVisitor)} */ void visitSuperConstructorInvocation(Java.SuperConstructorInvocation sci); } /** The visitor for all kinds of {@link Java.Atom}s. */ public interface AtomVisitor extends RvalueVisitor, TypeVisitor { /** Invoked by {@link Java.Package#accept(Visitor.AtomVisitor)}. */ void visitPackage(Java.Package p); } /** The visitor for all kinds of {@link Java.Type}s. */ public interface TypeVisitor { /** Invoked by {@link Java.ArrayType#accept(Visitor.TypeVisitor)} */ void visitArrayType(Java.ArrayType at); /** Invoked by {@link Java.BasicType#accept(Visitor.TypeVisitor)} */ void visitBasicType(Java.BasicType bt); /** Invoked by {@link Java.ReferenceType#accept(Visitor.TypeVisitor)} */ void visitReferenceType(Java.ReferenceType rt); /** Invoked by {@link Java.RvalueMemberType#accept(Visitor.TypeVisitor)} */ void visitRvalueMemberType(Java.RvalueMemberType rmt); /** Invoked by {@link Java.SimpleType#accept(Visitor.TypeVisitor)} */ void visitSimpleType(Java.SimpleType st); } /** The visitor for all kinds of {@link Java.Rvalue}s. */ public interface RvalueVisitor extends LvalueVisitor { /** Invoked by {@link Java.ArrayLength#accept(Visitor.RvalueVisitor)} */ void visitArrayLength(Java.ArrayLength al); /** Invoked by {@link Java.Assignment#accept(Visitor.RvalueVisitor)} */ void visitAssignment(Java.Assignment a); /** Invoked by {@link Java.UnaryOperation#accept(Visitor.RvalueVisitor)} */ void visitUnaryOperation(Java.UnaryOperation uo); /** Invoked by {@link Java.BinaryOperation#accept(Visitor.RvalueVisitor)} */ void visitBinaryOperation(Java.BinaryOperation bo); /** Invoked by {@link Java.Cast#accept(Visitor.RvalueVisitor)} */ void visitCast(Java.Cast c); /** Invoked by {@link Java.ClassLiteral#accept(Visitor.RvalueVisitor)} */ void visitClassLiteral(Java.ClassLiteral cl); /** Invoked by {@link Java.ConditionalExpression#accept(Visitor.RvalueVisitor)} */ void visitConditionalExpression(Java.ConditionalExpression ce); /** Invoked by {@link Java.Crement#accept(Visitor.RvalueVisitor)} */ void visitCrement(Java.Crement c); /** Invoked by {@link Java.Instanceof#accept(Visitor.RvalueVisitor)} */ void visitInstanceof(Java.Instanceof io); /** Invoked by {@link Java.MethodInvocation#accept(Visitor.RvalueVisitor)} */ void visitMethodInvocation(Java.MethodInvocation mi); /** Invoked by {@link Java.SuperclassMethodInvocation#accept(Visitor.RvalueVisitor)} */ void visitSuperclassMethodInvocation(Java.SuperclassMethodInvocation smi); /** Invoked by {@link Java.IntegerLiteral#accept(Visitor.RvalueVisitor)} */ void visitIntegerLiteral(Java.IntegerLiteral il); /** Invoked by {@link Java.FloatingPointLiteral#accept(Visitor.RvalueVisitor)} */ void visitFloatingPointLiteral(Java.FloatingPointLiteral fpl); /** Invoked by {@link Java.BooleanLiteral#accept(Visitor.RvalueVisitor)} */ void visitBooleanLiteral(Java.BooleanLiteral bl); /** Invoked by {@link Java.CharacterLiteral#accept(Visitor.RvalueVisitor)} */ void visitCharacterLiteral(Java.CharacterLiteral cl); /** Invoked by {@link Java.StringLiteral#accept(Visitor.RvalueVisitor)} */ void visitStringLiteral(Java.StringLiteral sl); /** Invoked by {@link Java.NullLiteral#accept(Visitor.RvalueVisitor)} */ void visitNullLiteral(Java.NullLiteral nl); /** Invoked by {@link Java.SimpleConstant#accept(Visitor.RvalueVisitor)} */ void visitSimpleConstant(Java.SimpleConstant sl); /** Invoked by {@link Java.NewAnonymousClassInstance#accept(Visitor.RvalueVisitor)} */ void visitNewAnonymousClassInstance(Java.NewAnonymousClassInstance naci); /** Invoked by {@link Java.NewArray#accept(Visitor.RvalueVisitor)} */ void visitNewArray(Java.NewArray na); /** Invoked by {@link Java.NewInitializedArray#accept(Visitor.RvalueVisitor)} */ void visitNewInitializedArray(Java.NewInitializedArray nia); /** Invoked by {@link Java.NewClassInstance#accept(Visitor.RvalueVisitor)} */ void visitNewClassInstance(Java.NewClassInstance nci); /** Invoked by {@link Java.ParameterAccess#accept(Visitor.RvalueVisitor)} */ void visitParameterAccess(Java.ParameterAccess pa); /** Invoked by {@link Java.QualifiedThisReference#accept(Visitor.RvalueVisitor)} */ void visitQualifiedThisReference(Java.QualifiedThisReference qtr); /** Invoked by {@link Java.ArrayLength#accept(Visitor.RvalueVisitor)} */ void visitThisReference(Java.ThisReference tr); } /** The visitor for all kinds of {@link Java.Lvalue}s. */ public interface LvalueVisitor { /** Invoked by {@link Java.AmbiguousName#accept(Visitor.LvalueVisitor)} */ void visitAmbiguousName(Java.AmbiguousName an); /** Invoked by {@link Java.ArrayAccessExpression#accept(Visitor.LvalueVisitor)} */ void visitArrayAccessExpression(Java.ArrayAccessExpression aae); /** Invoked by {@link Java.FieldAccess#accept(Visitor.LvalueVisitor)} */ void visitFieldAccess(Java.FieldAccess fa); /** Invoked by {@link Java.FieldAccessExpression#accept(Visitor.LvalueVisitor)} */ void visitFieldAccessExpression(Java.FieldAccessExpression fae); /** Invoked by {@link Java.SuperclassFieldAccessExpression#accept(Visitor.LvalueVisitor)} */ void visitSuperclassFieldAccessExpression(Java.SuperclassFieldAccessExpression scfae); /** Invoked by {@link Java.LocalVariableAccess#accept(Visitor.LvalueVisitor)} */ void visitLocalVariableAccess(Java.LocalVariableAccess lva); /** Invoked by {@link Java.ParenthesizedExpression#accept(Visitor.LvalueVisitor)} */ void visitParenthesizedExpression(Java.ParenthesizedExpression pe); } /** The visitor for all kinds of {@link Java.Annotation}s. */ public interface AnnotationVisitor { /** Invoked by {@link Java.MarkerAnnotation#accept(Visitor.AnnotationVisitor)} */ void visitMarkerAnnotation(Java.MarkerAnnotation ma); /** Invoked by {@link Java.NormalAnnotation#accept(Visitor.AnnotationVisitor)} */ void visitNormalAnnotation(Java.NormalAnnotation na); /** Invoked by {@link Java.SingleElementAnnotation#accept(Visitor.AnnotationVisitor)} */ void visitSingleElementAnnotation(Java.SingleElementAnnotation sea); } /** The visitor for all kinds of {@link Java.ElementValue}s. */ public interface ElementValueVisitor extends RvalueVisitor, AnnotationVisitor { /** Invoked by {@link Java.ElementValueArrayInitializer#accept(Visitor.ElementValueVisitor)} */ void visitElementValueArrayInitializer(Java.ElementValueArrayInitializer evai); } /** The visitor for all kinds of {@link Java.TypeArgument}s. */ public interface TypeArgumentVisitor { /** Invoked by {@link Java.Wildcard#accept(Visitor.TypeArgumentVisitor)} */ void visitWildcard(Java.Wildcard w); /** Invoked by {@link Java.ReferenceType#accept(Visitor.TypeArgumentVisitor)} */ void visitReferenceType(Java.ReferenceType rt); /** Invoked by {@link Java.ArrayType#accept(Visitor.TypeArgumentVisitor)} */ void visitArrayType(Java.ArrayType arrayType); } }