1 /* 2 * Copyright (c) 2001, 2006, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.tools.javac.tree; 27 28 import com.sun.tools.javac.util.*; 29 import com.sun.tools.javac.tree.JCTree.*; 30 31 /** A subclass of Tree.Visitor, this class defines 32 * a general tree scanner pattern. Translation proceeds recursively in 33 * left-to-right order down a tree. There is one visitor method in this class 34 * for every possible kind of tree node. To obtain a specific 35 * scanner, it suffices to override those visitor methods which 36 * do some interesting work. The scanner class itself takes care of all 37 * navigational aspects. 38 * 39 * <p><b>This is NOT part of any supported API. 40 * If you write code that depends on this, you do so at your own risk. 41 * This code and its internal interfaces are subject to change or 42 * deletion without notice.</b> 43 */ 44 public class TreeScanner extends Visitor { 45 46 /** Visitor method: Scan a single node. 47 */ 48 public void scan(JCTree tree) { 49 if(tree!=null) tree.accept(this); 50 } 51 52 /** Visitor method: scan a list of nodes. 53 */ 54 public void scan(List<? extends JCTree> trees) { 55 if (trees != null) 56 for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail) 57 scan(l.head); 58 } 59 60 61 /* *************************************************************************** 62 * Visitor methods 63 ****************************************************************************/ 64 65 public void visitTopLevel(JCCompilationUnit tree) { 66 scan(tree.packageAnnotations); 67 scan(tree.pid); 68 scan(tree.defs); 69 } 70 71 public void visitImport(JCImport tree) { 72 scan(tree.qualid); 73 } 74 75 public void visitClassDef(JCClassDecl tree) { 76 scan(tree.mods); 77 scan(tree.typarams); 78 scan(tree.extending); 79 scan(tree.implementing); 80 scan(tree.defs); 81 } 82 83 public void visitMethodDef(JCMethodDecl tree) { 84 scan(tree.mods); 85 scan(tree.restype); 86 scan(tree.typarams); 87 scan(tree.params); 88 scan(tree.receiverAnnotations); 89 scan(tree.thrown); 90 scan(tree.defaultValue); 91 scan(tree.body); 92 } 93 94 public void visitVarDef(JCVariableDecl tree) { 95 scan(tree.mods); 96 scan(tree.vartype); 97 scan(tree.init); 98 } 99 100 public void visitSkip(JCSkip tree) { 101 } 102 103 public void visitBlock(JCBlock tree) { 104 scan(tree.stats); 105 } 106 107 public void visitDoLoop(JCDoWhileLoop tree) { 108 scan(tree.body); 109 scan(tree.cond); 110 } 111 112 public void visitWhileLoop(JCWhileLoop tree) { 113 scan(tree.cond); 114 scan(tree.body); 115 } 116 117 public void visitForLoop(JCForLoop tree) { 118 scan(tree.init); 119 scan(tree.cond); 120 scan(tree.step); 121 scan(tree.body); 122 } 123 124 public void visitForeachLoop(JCEnhancedForLoop tree) { 125 scan(tree.var); 126 scan(tree.expr); 127 scan(tree.body); 128 } 129 130 public void visitLabelled(JCLabeledStatement tree) { 131 scan(tree.body); 132 } 133 134 public void visitSwitch(JCSwitch tree) { 135 scan(tree.selector); 136 scan(tree.cases); 137 } 138 139 public void visitCase(JCCase tree) { 140 scan(tree.pat); 141 scan(tree.stats); 142 } 143 144 public void visitSynchronized(JCSynchronized tree) { 145 scan(tree.lock); 146 scan(tree.body); 147 } 148 149 public void visitTry(JCTry tree) { 150 scan(tree.body); 151 scan(tree.catchers); 152 scan(tree.finalizer); 153 } 154 155 public void visitCatch(JCCatch tree) { 156 scan(tree.param); 157 scan(tree.body); 158 } 159 160 public void visitConditional(JCConditional tree) { 161 scan(tree.cond); 162 scan(tree.truepart); 163 scan(tree.falsepart); 164 } 165 166 public void visitIf(JCIf tree) { 167 scan(tree.cond); 168 scan(tree.thenpart); 169 scan(tree.elsepart); 170 } 171 172 public void visitExec(JCExpressionStatement tree) { 173 scan(tree.expr); 174 } 175 176 public void visitBreak(JCBreak tree) { 177 } 178 179 public void visitContinue(JCContinue tree) { 180 } 181 182 public void visitReturn(JCReturn tree) { 183 scan(tree.expr); 184 } 185 186 public void visitThrow(JCThrow tree) { 187 scan(tree.expr); 188 } 189 190 public void visitAssert(JCAssert tree) { 191 scan(tree.cond); 192 scan(tree.detail); 193 } 194 195 public void visitApply(JCMethodInvocation tree) { 196 scan(tree.typeargs); 197 scan(tree.meth); 198 scan(tree.args); 199 } 200 201 public void visitNewClass(JCNewClass tree) { 202 scan(tree.encl); 203 scan(tree.clazz); 204 scan(tree.typeargs); 205 scan(tree.args); 206 scan(tree.def); 207 } 208 209 public void visitNewArray(JCNewArray tree) { 210 scan(tree.annotations); 211 scan(tree.elemtype); 212 scan(tree.dims); 213 for (List<JCTypeAnnotation> annos : tree.dimAnnotations) 214 scan(annos); 215 scan(tree.elems); 216 } 217 218 public void visitParens(JCParens tree) { 219 scan(tree.expr); 220 } 221 222 public void visitAssign(JCAssign tree) { 223 scan(tree.lhs); 224 scan(tree.rhs); 225 } 226 227 public void visitAssignop(JCAssignOp tree) { 228 scan(tree.lhs); 229 scan(tree.rhs); 230 } 231 232 public void visitUnary(JCUnary tree) { 233 scan(tree.arg); 234 } 235 236 public void visitBinary(JCBinary tree) { 237 scan(tree.lhs); 238 scan(tree.rhs); 239 } 240 241 public void visitTypeCast(JCTypeCast tree) { 242 scan(tree.clazz); 243 scan(tree.expr); 244 } 245 246 public void visitTypeTest(JCInstanceOf tree) { 247 scan(tree.expr); 248 scan(tree.clazz); 249 } 250 251 public void visitIndexed(JCArrayAccess tree) { 252 scan(tree.indexed); 253 scan(tree.index); 254 } 255 256 public void visitSelect(JCFieldAccess tree) { 257 scan(tree.selected); 258 } 259 260 public void visitIdent(JCIdent tree) { 261 } 262 263 public void visitLiteral(JCLiteral tree) { 264 } 265 266 public void visitTypeIdent(JCPrimitiveTypeTree tree) { 267 } 268 269 public void visitTypeArray(JCArrayTypeTree tree) { 270 scan(tree.elemtype); 271 } 272 273 public void visitTypeApply(JCTypeApply tree) { 274 scan(tree.clazz); 275 scan(tree.arguments); 276 } 277 278 public void visitTypeDisjoint(JCTypeDisjoint tree) { 279 scan(tree.components); 280 } 281 282 public void visitTypeParameter(JCTypeParameter tree) { 283 scan(tree.annotations); 284 scan(tree.bounds); 285 } 286 287 @Override 288 public void visitWildcard(JCWildcard tree) { 289 scan(tree.kind); 290 if (tree.inner != null) 291 scan(tree.inner); 292 } 293 294 @Override 295 public void visitTypeBoundKind(TypeBoundKind that) { 296 } 297 298 public void visitModifiers(JCModifiers tree) { 299 scan(tree.annotations); 300 } 301 302 public void visitAnnotation(JCAnnotation tree) { 303 scan(tree.annotationType); 304 scan(tree.args); 305 } 306 307 public void visitAnnotatedType(JCAnnotatedType tree) { 308 scan(tree.annotations); 309 scan(tree.underlyingType); 310 } 311 312 public void visitErroneous(JCErroneous tree) { 313 } 314 315 public void visitLetExpr(LetExpr tree) { 316 scan(tree.defs); 317 scan(tree.expr); 318 } 319 320 public void visitTree(JCTree tree) { 321 assert false; 322 } 323 }