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.resources); 151 scan(tree.body); 152 scan(tree.catchers); 153 scan(tree.finalizer); 154 } 155 156 public void visitCatch(JCCatch tree) { 157 scan(tree.param); 158 scan(tree.body); 159 } 160 161 public void visitConditional(JCConditional tree) { 162 scan(tree.cond); 163 scan(tree.truepart); 164 scan(tree.falsepart); 165 } 166 167 public void visitIf(JCIf tree) { 168 scan(tree.cond); 169 scan(tree.thenpart); 170 scan(tree.elsepart); 171 } 172 173 public void visitExec(JCExpressionStatement tree) { 174 scan(tree.expr); 175 } 176 177 public void visitBreak(JCBreak tree) { 178 } 179 180 public void visitContinue(JCContinue tree) { 181 } 182 183 public void visitReturn(JCReturn tree) { 184 scan(tree.expr); 185 } 186 187 public void visitThrow(JCThrow tree) { 188 scan(tree.expr); 189 } 190 191 public void visitAssert(JCAssert tree) { 192 scan(tree.cond); 193 scan(tree.detail); 194 } 195 196 public void visitApply(JCMethodInvocation tree) { 197 scan(tree.typeargs); 198 scan(tree.meth); 199 scan(tree.args); 200 } 201 202 public void visitNewClass(JCNewClass tree) { 203 scan(tree.encl); 204 scan(tree.clazz); 205 scan(tree.typeargs); 206 scan(tree.args); 207 scan(tree.def); 208 } 209 210 public void visitNewArray(JCNewArray tree) { 211 scan(tree.annotations); 212 scan(tree.elemtype); 213 scan(tree.dims); 214 for (List<JCTypeAnnotation> annos : tree.dimAnnotations) 215 scan(annos); 216 scan(tree.elems); 217 } 218 219 public void visitParens(JCParens tree) { 220 scan(tree.expr); 221 } 222 223 public void visitAssign(JCAssign tree) { 224 scan(tree.lhs); 225 scan(tree.rhs); 226 } 227 228 public void visitAssignop(JCAssignOp tree) { 229 scan(tree.lhs); 230 scan(tree.rhs); 231 } 232 233 public void visitUnary(JCUnary tree) { 234 scan(tree.arg); 235 } 236 237 public void visitBinary(JCBinary tree) { 238 scan(tree.lhs); 239 scan(tree.rhs); 240 } 241 242 public void visitTypeCast(JCTypeCast tree) { 243 scan(tree.clazz); 244 scan(tree.expr); 245 } 246 247 public void visitTypeTest(JCInstanceOf tree) { 248 scan(tree.expr); 249 scan(tree.clazz); 250 } 251 252 public void visitIndexed(JCArrayAccess tree) { 253 scan(tree.indexed); 254 scan(tree.index); 255 } 256 257 public void visitSelect(JCFieldAccess tree) { 258 scan(tree.selected); 259 } 260 261 public void visitIdent(JCIdent tree) { 262 } 263 264 public void visitLiteral(JCLiteral tree) { 265 } 266 267 public void visitTypeIdent(JCPrimitiveTypeTree tree) { 268 } 269 270 public void visitTypeArray(JCArrayTypeTree tree) { 271 scan(tree.elemtype); 272 } 273 274 public void visitTypeApply(JCTypeApply tree) { 275 scan(tree.clazz); 276 scan(tree.arguments); 277 } 278 279 public void visitTypeDisjoint(JCTypeDisjoint tree) { 280 scan(tree.components); 281 } 282 283 public void visitTypeParameter(JCTypeParameter tree) { 284 scan(tree.annotations); 285 scan(tree.bounds); 286 } 287 288 @Override 289 public void visitWildcard(JCWildcard tree) { 290 scan(tree.kind); 291 if (tree.inner != null) 292 scan(tree.inner); 293 } 294 295 @Override 296 public void visitTypeBoundKind(TypeBoundKind that) { 297 } 298 299 public void visitModifiers(JCModifiers tree) { 300 scan(tree.annotations); 301 } 302 303 public void visitAnnotation(JCAnnotation tree) { 304 scan(tree.annotationType); 305 scan(tree.args); 306 } 307 308 public void visitAnnotatedType(JCAnnotatedType tree) { 309 scan(tree.annotations); 310 scan(tree.underlyingType); 311 } 312 313 public void visitErroneous(JCErroneous tree) { 314 } 315 316 public void visitLetExpr(LetExpr tree) { 317 scan(tree.defs); 318 scan(tree.expr); 319 } 320 321 public void visitTree(JCTree tree) { 322 assert false; 323 } 324 }