1.1 --- a/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/AstViewer.java Wed Sep 12 10:06:17 2012 +0200
1.2 +++ b/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/AstViewer.java Wed Sep 12 17:19:28 2012 +0200
1.3 @@ -451,7 +451,7 @@
1.4 //"--print-parse=true",
1.5 "--debug-lines=false",
1.6 "--print-symbols=true",
1.7 - "--dump-ir-graph=true",
1.8 +// "--dump-ir-graph=true",
1.9 "--print-symbols=true"});
1.10 end = System.currentTimeMillis();
1.11 // System.out.println("Nashron creating options: " + (end - start));
2.1 --- a/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/DefaultScanner.java Wed Sep 12 10:06:17 2012 +0200
2.2 +++ b/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/DefaultScanner.java Wed Sep 12 17:19:28 2012 +0200
2.3 @@ -55,7 +55,6 @@
2.4 import com.oracle.nashorn.ir.LineNumberNode;
2.5 import com.oracle.nashorn.ir.LiteralNode;
2.6 import com.oracle.nashorn.ir.Node;
2.7 -import com.oracle.nashorn.ir.NodeVisitor;
2.8 import com.oracle.nashorn.ir.ObjectNode;
2.9 import com.oracle.nashorn.ir.PropertyNode;
2.10 import com.oracle.nashorn.ir.ReferenceNode;
2.11 @@ -69,6 +68,7 @@
2.12 import com.oracle.nashorn.ir.VarNode;
2.13 import com.oracle.nashorn.ir.WhileNode;
2.14 import com.oracle.nashorn.ir.WithNode;
2.15 +import com.oracle.nashorn.ir.visitor.NodeVisitor;
2.16
2.17 /**
2.18 *
2.19 @@ -81,183 +81,183 @@
2.20 }
2.21
2.22 @Override
2.23 - public Node visit(AccessNode accessNode, boolean onset) {
2.24 + public Node enter(AccessNode accessNode) {
2.25 scan(accessNode);
2.26 - return super.visit(accessNode, onset);
2.27 + return super.enter(accessNode);
2.28 }
2.29
2.30 @Override
2.31 - public Node visit(BinaryNode binaryNode, boolean onset) {
2.32 + public Node enter(BinaryNode binaryNode) {
2.33 scan(binaryNode);
2.34 - return super.visit(binaryNode, onset);
2.35 + return super.enter(binaryNode);
2.36 }
2.37
2.38 @Override
2.39 - public Node visit(Block block, boolean onset) {
2.40 + public Node enter(Block block) {
2.41 scan(block);
2.42 - return super.visit(block, onset);
2.43 + return super.enter(block);
2.44 }
2.45
2.46 @Override
2.47 - public Node visit(BreakNode breakNode, boolean onset) {
2.48 + public Node enter(BreakNode breakNode) {
2.49 scan(breakNode);
2.50 - return super.visit(breakNode, onset);
2.51 + return super.enter(breakNode);
2.52 }
2.53
2.54 @Override
2.55 - public Node visit(CallNode callNode, boolean onset) {
2.56 + public Node enter(CallNode callNode) {
2.57 scan(callNode);
2.58 - return super.visit(callNode, onset);
2.59 + return super.enter(callNode);
2.60 }
2.61
2.62 @Override
2.63 - public Node visit(CaseNode caseNode, boolean onset) {
2.64 + public Node enter(CaseNode caseNode) {
2.65 scan(caseNode);
2.66 - return super.visit(caseNode, onset);
2.67 + return super.enter(caseNode);
2.68 }
2.69
2.70 @Override
2.71 - public Node visit(CatchNode catchNode, boolean onset) {
2.72 + public Node enter(CatchNode catchNode) {
2.73 scan(catchNode);
2.74 - return super.visit(catchNode, onset);
2.75 + return super.enter(catchNode);
2.76 }
2.77
2.78 @Override
2.79 - public Node visit(ContinueNode continueNode, boolean onset) {
2.80 + public Node enter(ContinueNode continueNode) {
2.81 scan(continueNode);
2.82 - return super.visit(continueNode, onset);
2.83 + return super.enter(continueNode);
2.84 }
2.85
2.86 @Override
2.87 - public Node visit(ExecuteNode executeNode, boolean onset) {
2.88 + public Node enter(ExecuteNode executeNode) {
2.89 scan(executeNode);
2.90 - return super.visit(executeNode, onset);
2.91 + return super.enter(executeNode);
2.92 }
2.93
2.94 @Override
2.95 - public Node visit(ForNode forNode, boolean onset) {
2.96 + public Node enter(ForNode forNode) {
2.97 scan(forNode);
2.98 - return super.visit(forNode, onset);
2.99 + return super.enter(forNode);
2.100 }
2.101
2.102 @Override
2.103 - public Node visit(FunctionNode functionNode, boolean onset) {
2.104 + public Node enter(FunctionNode functionNode) {
2.105 scan(functionNode);
2.106 - return super.visit(functionNode, onset);
2.107 + return super.enter(functionNode);
2.108 }
2.109
2.110 @Override
2.111 - public Node visit(IdentNode identNode, boolean onset) {
2.112 + public Node enter(IdentNode identNode) {
2.113 scan(identNode);
2.114 - return super.visit(identNode, onset);
2.115 + return super.enter(identNode);
2.116 }
2.117
2.118 @Override
2.119 - public Node visit(IfNode ifNode, boolean onset) {
2.120 + public Node enter(IfNode ifNode) {
2.121 scan(ifNode);
2.122 - return super.visit(ifNode, onset);
2.123 + return super.enter(ifNode);
2.124 }
2.125
2.126 @Override
2.127 - public Node visit(IndexNode indexNode, boolean onset) {
2.128 + public Node enter(IndexNode indexNode) {
2.129 scan(indexNode);
2.130 - return super.visit(indexNode, onset);
2.131 + return super.enter(indexNode);
2.132 }
2.133
2.134 @Override
2.135 - public Node visit(LabelNode labeledNode, boolean onset) {
2.136 + public Node enter(LabelNode labeledNode) {
2.137 scan(labeledNode);
2.138 - return super.visit(labeledNode, onset);
2.139 + return super.enter(labeledNode);
2.140 }
2.141
2.142 @Override
2.143 - public Node visit(LineNumberNode lineNumberNode, boolean onset) {
2.144 + public Node enter(LineNumberNode lineNumberNode) {
2.145 scan(lineNumberNode);
2.146 - return super.visit(lineNumberNode, onset);
2.147 + return super.enter(lineNumberNode);
2.148 }
2.149
2.150 @Override
2.151 - public Node visit(LiteralNode literalNode, boolean onset) {
2.152 + public Node enter(LiteralNode literalNode) {
2.153 scan(literalNode);
2.154 - return super.visit(literalNode, onset);
2.155 + return super.enter(literalNode);
2.156 }
2.157
2.158 @Override
2.159 - public Node visit(ObjectNode objectNode, boolean onset) {
2.160 + public Node enter(ObjectNode objectNode) {
2.161 scan(objectNode);
2.162 - return super.visit(objectNode, onset);
2.163 + return super.enter(objectNode);
2.164 }
2.165
2.166 @Override
2.167 - public Node visit(PropertyNode propertyNode, boolean onset) {
2.168 + public Node enter(PropertyNode propertyNode) {
2.169 scan(propertyNode);
2.170 - return super.visit(propertyNode, onset);
2.171 + return super.enter(propertyNode);
2.172 }
2.173
2.174 @Override
2.175 - public Node visit(ReferenceNode referenceNode, boolean onset) {
2.176 + public Node enter(ReferenceNode referenceNode) {
2.177 scan(referenceNode);
2.178 - return super.visit(referenceNode, onset);
2.179 + return super.enter(referenceNode);
2.180 }
2.181
2.182 @Override
2.183 - public Node visit(ReturnNode returnNode, boolean onset) {
2.184 + public Node enter(ReturnNode returnNode) {
2.185 scan(returnNode);
2.186 - return super.visit(returnNode, onset);
2.187 + return super.enter(returnNode);
2.188 }
2.189
2.190 @Override
2.191 - public Node visit(RuntimeNode runtimeNode, boolean onset) {
2.192 + public Node enter(RuntimeNode runtimeNode) {
2.193 scan(runtimeNode);
2.194 - return super.visit(runtimeNode, onset);
2.195 + return super.enter(runtimeNode);
2.196 }
2.197
2.198 @Override
2.199 - public Node visit(SwitchNode switchNode, boolean onset) {
2.200 + public Node enter(SwitchNode switchNode) {
2.201 scan(switchNode);
2.202 - return super.visit(switchNode, onset);
2.203 + return super.enter(switchNode);
2.204 }
2.205
2.206 @Override
2.207 - public Node visit(TernaryNode ternaryNode, boolean onset) {
2.208 + public Node enter(TernaryNode ternaryNode) {
2.209 scan(ternaryNode);
2.210 - return super.visit(ternaryNode, onset);
2.211 + return super.enter(ternaryNode);
2.212 }
2.213
2.214 @Override
2.215 - public Node visit(ThrowNode throwNode, boolean onset) {
2.216 + public Node enter(ThrowNode throwNode) {
2.217 scan(throwNode);
2.218 - return super.visit(throwNode, onset);
2.219 + return super.enter(throwNode);
2.220 }
2.221
2.222 @Override
2.223 - public Node visit(TryNode tryNode, boolean onset) {
2.224 + public Node enter(TryNode tryNode) {
2.225 scan(tryNode);
2.226 - return super.visit(tryNode, onset);
2.227 + return super.enter(tryNode);
2.228 }
2.229
2.230 @Override
2.231 - public Node visit(UnaryNode unaryNode, boolean onset) {
2.232 + public Node enter(UnaryNode unaryNode) {
2.233 scan(unaryNode);
2.234 - return super.visit(unaryNode, onset);
2.235 + return super.enter(unaryNode);
2.236 }
2.237
2.238 @Override
2.239 - public Node visit(VarNode varNode, boolean onset) {
2.240 + public Node enter(VarNode varNode) {
2.241 scan(varNode);
2.242 - return super.visit(varNode, onset);
2.243 + return super.enter(varNode);
2.244 }
2.245
2.246 @Override
2.247 - public Node visit(WhileNode whileNode, boolean onset) {
2.248 + public Node enter(WhileNode whileNode) {
2.249 scan(whileNode);
2.250 - return super.visit(whileNode, onset);
2.251 + return super.enter(whileNode);
2.252 }
2.253
2.254 @Override
2.255 - public Node visit(WithNode withNode, boolean onset) {
2.256 + public Node enter(WithNode withNode) {
2.257 scan(withNode);
2.258 - return super.visit(withNode, onset);
2.259 + return super.enter(withNode);
2.260 }
2.261
2.262 }
3.1 --- a/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/DetailTreeNodeVisitor.java Wed Sep 12 10:06:17 2012 +0200
3.2 +++ b/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/DetailTreeNodeVisitor.java Wed Sep 12 17:19:28 2012 +0200
3.3 @@ -55,7 +55,6 @@
3.4 import com.oracle.nashorn.ir.LineNumberNode;
3.5 import com.oracle.nashorn.ir.LiteralNode;
3.6 import com.oracle.nashorn.ir.Node;
3.7 -import com.oracle.nashorn.ir.NodeVisitor;
3.8 import com.oracle.nashorn.ir.ObjectNode;
3.9 import com.oracle.nashorn.ir.PropertyNode;
3.10 import com.oracle.nashorn.ir.ReferenceNode;
3.11 @@ -70,6 +69,7 @@
3.12 import com.oracle.nashorn.ir.VarNode;
3.13 import com.oracle.nashorn.ir.WhileNode;
3.14 import com.oracle.nashorn.ir.WithNode;
3.15 +import com.oracle.nashorn.ir.visitor.NodeVisitor;
3.16 import com.oracle.nashorn.parser.Token;
3.17 import java.util.ArrayList;
3.18 import java.util.List;
3.19 @@ -139,104 +139,135 @@
3.20
3.21
3.22 @Override
3.23 - public Node visit(AccessNode accessNode, boolean onset) {
3.24 - return notComplete(accessNode, onset);
3.25 + public Node enter(AccessNode accessNode) {
3.26 + return notComplete(accessNode, true);
3.27 }
3.28
3.29 @Override
3.30 - public Node visit(BinaryNode iNode, boolean onset) {
3.31 - if (onset) {
3.32 + public Node leave(AccessNode accessNode) {
3.33 + return notComplete(accessNode, false);
3.34 + }
3.35 +
3.36 + @Override
3.37 + public Node enter(BinaryNode iNode) {
3.38 // int[] offsets = OffsetUtils.getOffsets(iNode);
3.39 - int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.40 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.41 - iNode.getClass().getSimpleName() + " " + iNode.tokenType().getName(),
3.42 - offsets[0], offsets[1]);
3.43 - parentNode.addChild(adapter);
3.44 - parents.add(parentNode);
3.45 - parentNode = adapter;
3.46 -
3.47 - } else {
3.48 - parentNode = parents.remove(parents.size() - 1);
3.49 -
3.50 - }
3.51 + int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.52 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.53 + iNode.getClass().getSimpleName() + " " + iNode.tokenType().getName(),
3.54 + offsets[0], offsets[1]);
3.55 + parentNode.addChild(adapter);
3.56 + parents.add(parentNode);
3.57 + parentNode = adapter;
3.58 return iNode;
3.59 }
3.60
3.61 @Override
3.62 - public Node visit(Block iNode, boolean onset) {
3.63 - if (onset) {
3.64 - int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.65 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.66 - "<font>" +iNode.getClass().getSimpleName() + "</font>",
3.67 - offsets[0], offsets[1]);
3.68 -
3.69 - parentNode.addChild(adapter);
3.70 - parents.add(parentNode);
3.71 - parentNode = adapter;
3.72 -
3.73 - TreeCreator.TreeASTNodeAdapter frame = new TreeCreator.TreeASTNodeAdapter (parentNode,
3.74 - "<font color='gray'>Frame:</font>", iNode.getStart(), iNode.getFinish());
3.75 - parentNode.addChild(frame);
3.76 - parents.add(parentNode);
3.77 - parentNode = frame;
3.78 -
3.79 - TreeCreator.TreeASTNodeAdapter variables = new TreeCreator.TreeASTNodeAdapter (parentNode,
3.80 - "<font color='gray'>Variables:</font>", iNode.getStart(), iNode.getFinish());
3.81 - parentNode.addChild(variables);
3.82 - parents.add(parentNode);
3.83 - parentNode = frame;
3.84 -
3.85 - if (iNode.getFrame() != null) {
3.86 - TreeCreator.TreeASTNodeAdapter symbolAdapter;
3.87 - for (Symbol symbol: iNode.getFrame().getSymbols()) {
3.88 - variables.addChild(new TreeCreator.TreeASTNodeAdapter(variables,
3.89 - "<font color='gray'>" + symbol.getName() + "</font>"));
3.90 - }
3.91 - }
3.92 -
3.93 - parentNode = parents.remove(parents.size() - 1);
3.94 -
3.95 - parentNode = parents.remove(parents.size() - 1);
3.96 -
3.97 - parentNode = parents.remove(parents.size() - 1);
3.98 - return null;
3.99 - } else {
3.100 - return iNode;
3.101 - }
3.102 + public Node leave(BinaryNode iNode) {
3.103 + parentNode = parents.remove(parents.size() - 1);
3.104 + return iNode;
3.105 }
3.106
3.107 @Override
3.108 - public Node visit(BreakNode breakNode, boolean onset) {
3.109 - return notComplete(breakNode, onset);
3.110 + public Node enter(Block iNode) {
3.111 + int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.112 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.113 + "<font>" +iNode.getClass().getSimpleName() + "</font>",
3.114 + offsets[0], offsets[1]);
3.115 +
3.116 + parentNode.addChild(adapter);
3.117 + parents.add(parentNode);
3.118 + parentNode = adapter;
3.119 +
3.120 + TreeCreator.TreeASTNodeAdapter frame = new TreeCreator.TreeASTNodeAdapter (parentNode,
3.121 + "<font color='gray'>Frame:</font>", iNode.getStart(), iNode.getFinish());
3.122 + parentNode.addChild(frame);
3.123 + parents.add(parentNode);
3.124 + parentNode = frame;
3.125 +
3.126 + TreeCreator.TreeASTNodeAdapter variables = new TreeCreator.TreeASTNodeAdapter (parentNode,
3.127 + "<font color='gray'>Variables:</font>", iNode.getStart(), iNode.getFinish());
3.128 + parentNode.addChild(variables);
3.129 + parents.add(parentNode);
3.130 + parentNode = frame;
3.131 +
3.132 + if (iNode.getFrame() != null) {
3.133 + TreeCreator.TreeASTNodeAdapter symbolAdapter;
3.134 + for (Symbol symbol: iNode.getFrame().getSymbols()) {
3.135 + variables.addChild(new TreeCreator.TreeASTNodeAdapter(variables,
3.136 + "<font color='gray'>" + symbol.getName() + "</font>"));
3.137 + }
3.138 + }
3.139 +
3.140 + parentNode = parents.remove(parents.size() - 1);
3.141 +
3.142 + parentNode = parents.remove(parents.size() - 1);
3.143 +
3.144 + parentNode = parents.remove(parents.size() - 1);
3.145 + return null;
3.146 }
3.147
3.148 @Override
3.149 - public Node visit(CallNode callNode, boolean onset) {
3.150 - return notComplete(callNode, onset);
3.151 + public Node enter(BreakNode breakNode) {
3.152 + return notComplete(breakNode, true);
3.153 }
3.154
3.155 @Override
3.156 - public Node visit(CaseNode caseNode, boolean onset) {
3.157 - return notComplete(caseNode, onset);
3.158 + public Node leave(BreakNode breakNode) {
3.159 + return notComplete(breakNode, false);
3.160 }
3.161
3.162 @Override
3.163 - public Node visit(CatchNode catchNode, boolean onset) {
3.164 - return notComplete(catchNode, onset);
3.165 + public Node enter(CallNode callNode) {
3.166 + return notComplete(callNode, true);
3.167 }
3.168
3.169 @Override
3.170 - public Node visit(ContinueNode continueNode, boolean onset) {
3.171 - return notComplete(continueNode, onset);
3.172 + public Node leave(CallNode callNode) {
3.173 + return notComplete(callNode, false);
3.174 }
3.175
3.176 @Override
3.177 - public Node visit(ExecuteNode executeNode, boolean onset) {
3.178 - return notComplete(executeNode, onset);
3.179 + public Node enter(CaseNode caseNode) {
3.180 + return notComplete(caseNode, true);
3.181 + }
3.182 +
3.183 + @Override
3.184 + public Node leave(CaseNode caseNode) {
3.185 + return notComplete(caseNode, false);
3.186 + }
3.187 +
3.188 + @Override
3.189 + public Node enter(CatchNode catchNode) {
3.190 + return notComplete(catchNode, true);
3.191 + }
3.192 +
3.193 + @Override
3.194 + public Node leave(CatchNode catchNode) {
3.195 + return notComplete(catchNode, false);
3.196 + }
3.197 +
3.198 + @Override
3.199 + public Node enter(ContinueNode continueNode) {
3.200 + return notComplete(continueNode, true);
3.201 + }
3.202 +
3.203 + @Override
3.204 + public Node leave(ContinueNode continueNode) {
3.205 + return notComplete(continueNode, false);
3.206 + }
3.207 +
3.208 + @Override
3.209 + public Node enter(ExecuteNode executeNode) {
3.210 + return notComplete(executeNode, true);
3.211 + }
3.212 +
3.213 + @Override
3.214 + public Node leave(ExecuteNode executeNode) {
3.215 + return notComplete(executeNode, false);
3.216 }
3.217
3.218 // @Override
3.219 -// public Node visit(ErrorNode iNode, boolean onset) {
3.220 +// public Node enter(ErrorNode iNode) {
3.221 // if (onset) {
3.222 // int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.223 // TreeASTNodeAdapter adapter = new TreeASTNodeAdapter(parentNode,
3.224 @@ -257,181 +288,266 @@
3.225
3.226
3.227 @Override
3.228 - public Node visit(ForNode forNode, boolean onset) {
3.229 - return notComplete(forNode, onset);
3.230 + public Node enter(ForNode forNode) {
3.231 + return notComplete(forNode, true);
3.232 }
3.233
3.234 @Override
3.235 - public Node visit(FunctionNode functionNode, boolean onset) {
3.236 - if (onset) {
3.237 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.238 - functionNode.getClass().getSimpleName() + " <b>" + functionNode.getName() + "</b>",
3.239 - "<html>Name: " + functionNode.getName() +"<br/>"
3.240 - + "Kind: " + functionNode.getKind().toString() +"<br/>"
3.241 - + "</html>",
3.242 - Token.descPosition(functionNode.getFirstToken()), Token.descPosition(functionNode.getLastToken()) + Token.descLength(functionNode.getLastToken()));
3.243 - //(int)functionNode.position(), (int)(functionNode.position() + functionNode.length()));
3.244 - parentNode.addChild(adapter);
3.245 - parents.add(parentNode);
3.246 - parentNode = adapter;
3.247 + public Node leave(ForNode forNode) {
3.248 + return notComplete(forNode, false);
3.249 + }
3.250 +
3.251 + @Override
3.252 + public Node enter(FunctionNode functionNode) {
3.253 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.254 + functionNode.getClass().getSimpleName() + " <b>" + functionNode.getName() + "</b>",
3.255 + "<html>Name: " + functionNode.getName() +"<br/>"
3.256 + + "Kind: " + functionNode.getKind().toString() +"<br/>"
3.257 + + "</html>",
3.258 + Token.descPosition(functionNode.getFirstToken()), Token.descPosition(functionNode.getLastToken()) + Token.descLength(functionNode.getLastToken()));
3.259 + //(int)functionNode.position(), (int)(functionNode.position() + functionNode.length()));
3.260 + parentNode.addChild(adapter);
3.261 + parents.add(parentNode);
3.262 + parentNode = adapter;
3.263 // parentNode.addChild(new TreeASTNodeAdapter(parentNode,
3.264 // "Name: " + functionNode.getName(),
3.265 // 0,0));
3.266 - } else {
3.267 - parentNode = parents.remove(parents.size() - 1);
3.268 - }
3.269 +
3.270 return functionNode;
3.271 }
3.272
3.273 @Override
3.274 - public Node visit(IdentNode identNode, boolean onset) {
3.275 - if (onset) {
3.276 - int[] offsets = OffsetUtils.getOffsets(identNode);
3.277 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.278 - identNode.getClass().getSimpleName() + " <b>" + identNode.getName() + "</b>",
3.279 - offsets[0], offsets[1]);
3.280 - parentNode.addChild(adapter);
3.281 - parents.add(parentNode);
3.282 - parentNode = adapter;
3.283 -// return super.visit(identNode, onset);
3.284 - } else {
3.285 - parentNode = parents.remove(parents.size() - 1);
3.286 + public Node leave(FunctionNode functionNode) {
3.287 + parentNode = parents.remove(parents.size() - 1);
3.288 + return functionNode;
3.289 + }
3.290 +
3.291 + @Override
3.292 + public Node enter(IdentNode identNode) {
3.293 + int[] offsets = OffsetUtils.getOffsets(identNode);
3.294 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.295 + identNode.getClass().getSimpleName() + " <b>" + identNode.getName() + "</b>",
3.296 + offsets[0], offsets[1]);
3.297 + parentNode.addChild(adapter);
3.298 + parents.add(parentNode);
3.299 + parentNode = adapter;
3.300 +// return super.visit(identNode, true);
3.301 // return null;
3.302 - }
3.303 return identNode;
3.304 }
3.305
3.306 @Override
3.307 - public Node visit(IfNode iNode, boolean onset) {
3.308 - if (onset) {
3.309 - int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.310 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.311 - "<font>" +iNode.getClass().getSimpleName() + "</font>",
3.312 - offsets[0], offsets[1]);
3.313 -
3.314 - parentNode.addChild(adapter);
3.315 - parents.add(parentNode);
3.316 - parentNode = adapter;
3.317 -
3.318 - processInfoNode("Condition", iNode.getTest().getStart(), iNode.getTest().getFinish(), iNode.getTest());
3.319 - processInfoNode("Pass", iNode.getPass().getStart(), iNode.getPass().getFinish(), iNode.getPass());
3.320 - if (iNode.getFail() != null) {
3.321 - processInfoNode("Fail", iNode.getFail().getStart(), iNode.getFail().getFinish(), iNode.getFail());
3.322 - }
3.323 -
3.324 - parentNode = parents.remove(parents.size() - 1);
3.325 - return null;
3.326 - } else {
3.327 - return iNode;
3.328 - }
3.329 -
3.330 + public Node leave(IdentNode identNode) {
3.331 + parentNode = parents.remove(parents.size() - 1);
3.332 + return identNode;
3.333 }
3.334
3.335 @Override
3.336 - public Node visit(IndexNode indexNode, boolean onset) {
3.337 - return notComplete(indexNode, onset);
3.338 + public Node enter(IfNode iNode) {
3.339 + int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
3.340 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.341 + "<font>" +iNode.getClass().getSimpleName() + "</font>",
3.342 + offsets[0], offsets[1]);
3.343 +
3.344 + parentNode.addChild(adapter);
3.345 + parents.add(parentNode);
3.346 + parentNode = adapter;
3.347 +
3.348 + processInfoNode("Condition", iNode.getTest().getStart(), iNode.getTest().getFinish(), iNode.getTest());
3.349 + processInfoNode("Pass", iNode.getPass().getStart(), iNode.getPass().getFinish(), iNode.getPass());
3.350 + if (iNode.getFail() != null) {
3.351 + processInfoNode("Fail", iNode.getFail().getStart(), iNode.getFail().getFinish(), iNode.getFail());
3.352 + }
3.353 +
3.354 + parentNode = parents.remove(parents.size() - 1);
3.355 + return null;
3.356 }
3.357
3.358 @Override
3.359 - public Node visit(LabelNode labeledNode, boolean onset) {
3.360 - return notComplete(labeledNode, onset);
3.361 + public Node enter(IndexNode indexNode) {
3.362 + return notComplete(indexNode, true);
3.363 }
3.364
3.365 @Override
3.366 - public Node visit(LineNumberNode node, boolean onset) {
3.367 - return visitSimpleNode(node, "", "Line number: " + node.getLineNumber(), onset);
3.368 + public Node leave(IndexNode indexNode) {
3.369 + return notComplete(indexNode, false);
3.370 }
3.371
3.372 @Override
3.373 - public Node visit(LiteralNode literalNode, boolean onset) {
3.374 - return notComplete(literalNode, onset);
3.375 + public Node enter(LabelNode labeledNode) {
3.376 + return notComplete(labeledNode, true);
3.377 }
3.378
3.379 @Override
3.380 - public Node visit(ObjectNode objectNode, boolean onset) {
3.381 - return notComplete(objectNode, onset);
3.382 + public Node leave(LabelNode labeledNode) {
3.383 + return notComplete(labeledNode, false);
3.384 }
3.385
3.386 @Override
3.387 - public Node visit(PropertyNode propertyNode, boolean onset) {
3.388 - return notComplete(propertyNode, onset);
3.389 + public Node enter(LineNumberNode node) {
3.390 + return visitSimpleNode(node, "", "Line number: " + node.getLineNumber(), true);
3.391 }
3.392
3.393 @Override
3.394 - public Node visit(ReferenceNode node, boolean onset) {
3.395 - if (onset) {
3.396 - int[] offsets = OffsetUtils.getOffsets(node);
3.397 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.398 - node.getClass().getSimpleName(),
3.399 - offsets[0], offsets[1]);
3.400 - parentNode.addChild(adapter);
3.401 - parents.add(parentNode);
3.402 - parentNode = adapter;
3.403 - Object ref = node.getReference();
3.404 - if (ref != null) {
3.405 - if (ref instanceof FunctionNode) {
3.406 - //((FunctionNode)ref).accept(this);
3.407 - }
3.408 - else
3.409 - adapter.addChild(new TreeCreator.TreeASTNodeAdapter(parentNode,
3.410 - "<font color='gray'>" + ref.getClass().getSimpleName() + "</font>"));
3.411 + public Node leave(LineNumberNode node) {
3.412 + return visitSimpleNode(node, "", "Line number: " + node.getLineNumber(), false);
3.413 + }
3.414 +
3.415 + @Override
3.416 + public Node enter(LiteralNode literalNode) {
3.417 + return notComplete(literalNode, true);
3.418 + }
3.419 +
3.420 + @Override
3.421 + public Node leave(LiteralNode literalNode) {
3.422 + return notComplete(literalNode, false);
3.423 + }
3.424 +
3.425 + @Override
3.426 + public Node enter(ObjectNode objectNode) {
3.427 + return notComplete(objectNode, true);
3.428 + }
3.429 +
3.430 + @Override
3.431 + public Node leave(ObjectNode objectNode) {
3.432 + return notComplete(objectNode, false);
3.433 + }
3.434 +
3.435 + @Override
3.436 + public Node enter(PropertyNode propertyNode) {
3.437 + return notComplete(propertyNode, true);
3.438 + }
3.439 +
3.440 + @Override
3.441 + public Node leave(PropertyNode propertyNode) {
3.442 + return notComplete(propertyNode, false);
3.443 + }
3.444 +
3.445 + @Override
3.446 + public Node enter(ReferenceNode node) {
3.447 + int[] offsets = OffsetUtils.getOffsets(node);
3.448 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
3.449 + node.getClass().getSimpleName(),
3.450 + offsets[0], offsets[1]);
3.451 + parentNode.addChild(adapter);
3.452 + parents.add(parentNode);
3.453 + parentNode = adapter;
3.454 + Object ref = node.getReference();
3.455 + if (ref != null) {
3.456 + if (ref instanceof FunctionNode) {
3.457 + //((FunctionNode)ref).accept(this);
3.458 }
3.459 -// return node;
3.460 - } else {
3.461 - parentNode = parents.remove(parents.size() - 1);
3.462 -// return null;
3.463 + else
3.464 + adapter.addChild(new TreeCreator.TreeASTNodeAdapter(parentNode,
3.465 + "<font color='gray'>" + ref.getClass().getSimpleName() + "</font>"));
3.466 }
3.467 return node;
3.468 }
3.469
3.470 @Override
3.471 - public Node visit(ReturnNode returnNode, boolean onset) {
3.472 - return notComplete(returnNode, onset);
3.473 + public Node leave(ReferenceNode node) {
3.474 + parentNode = parents.remove(parents.size() - 1);
3.475 + return node;
3.476 }
3.477
3.478 @Override
3.479 - public Node visit(RuntimeNode runtimeNode, boolean onset) {
3.480 - return notComplete(runtimeNode, onset);
3.481 + public Node enter(ReturnNode returnNode) {
3.482 + return notComplete(returnNode, true);
3.483 }
3.484
3.485 @Override
3.486 - public Node visit(SwitchNode switchNode, boolean onset) {
3.487 - return notComplete(switchNode, onset);
3.488 + public Node leave(ReturnNode returnNode) {
3.489 + return notComplete(returnNode, false);
3.490 }
3.491
3.492 @Override
3.493 - public Node visit(TernaryNode ternaryNode, boolean onset) {
3.494 - return notComplete(ternaryNode, onset);
3.495 + public Node enter(RuntimeNode runtimeNode) {
3.496 + return notComplete(runtimeNode, true);
3.497 }
3.498
3.499 @Override
3.500 - public Node visit(ThrowNode throwNode, boolean onset) {
3.501 - return notComplete(throwNode, onset);
3.502 + public Node leave(RuntimeNode runtimeNode) {
3.503 + return notComplete(runtimeNode, false);
3.504 }
3.505
3.506 @Override
3.507 - public Node visit(TryNode tryNode, boolean onset) {
3.508 - return notComplete(tryNode, onset);
3.509 + public Node enter(SwitchNode switchNode) {
3.510 + return notComplete(switchNode, true);
3.511 }
3.512
3.513 @Override
3.514 - public Node visit(UnaryNode unaryNode, boolean onset) {
3.515 - return notComplete(unaryNode, onset);
3.516 + public Node leave(SwitchNode switchNode) {
3.517 + return notComplete(switchNode, false);
3.518 }
3.519
3.520 @Override
3.521 - public Node visit(VarNode varNode, boolean onset) {
3.522 - return notComplete(varNode, onset);
3.523 + public Node enter(TernaryNode ternaryNode) {
3.524 + return notComplete(ternaryNode, true);
3.525 }
3.526
3.527 @Override
3.528 - public Node visit(WhileNode whileNode, boolean onset) {
3.529 - return notComplete(whileNode, onset);
3.530 + public Node leave(TernaryNode ternaryNode) {
3.531 + return notComplete(ternaryNode, false);
3.532 }
3.533
3.534 @Override
3.535 - public Node visit(WithNode withNode, boolean onset) {
3.536 - return notComplete(withNode, onset);
3.537 + public Node enter(ThrowNode throwNode) {
3.538 + return notComplete(throwNode, true);
3.539 + }
3.540 +
3.541 + @Override
3.542 + public Node leave(ThrowNode throwNode) {
3.543 + return notComplete(throwNode, false);
3.544 + }
3.545 +
3.546 + @Override
3.547 + public Node enter(TryNode tryNode) {
3.548 + return notComplete(tryNode, true);
3.549 + }
3.550 +
3.551 + @Override
3.552 + public Node leave(TryNode tryNode) {
3.553 + return notComplete(tryNode, false);
3.554 + }
3.555 +
3.556 + @Override
3.557 + public Node enter(UnaryNode unaryNode) {
3.558 + return notComplete(unaryNode, true);
3.559 + }
3.560 +
3.561 + @Override
3.562 + public Node leave(UnaryNode unaryNode) {
3.563 + return notComplete(unaryNode, false);
3.564 + }
3.565 +
3.566 + @Override
3.567 + public Node enter(VarNode varNode) {
3.568 + return notComplete(varNode, true);
3.569 + }
3.570 +
3.571 + @Override
3.572 + public Node leave(VarNode varNode) {
3.573 + return notComplete(varNode, false);
3.574 + }
3.575 +
3.576 + @Override
3.577 + public Node enter(WhileNode whileNode) {
3.578 + return notComplete(whileNode, true);
3.579 + }
3.580 +
3.581 + @Override
3.582 + public Node leave(WhileNode whileNode) {
3.583 + return notComplete(whileNode, false);
3.584 + }
3.585 +
3.586 + @Override
3.587 + public Node enter(WithNode withNode) {
3.588 + return notComplete(withNode, true);
3.589 + }
3.590 +
3.591 + @Override
3.592 + public Node leave(WithNode withNode) {
3.593 + return notComplete(withNode, false);
3.594 }
3.595
3.596 }
4.1 --- a/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/OffsetUtils.java Wed Sep 12 10:06:17 2012 +0200
4.2 +++ b/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/OffsetUtils.java Wed Sep 12 17:19:28 2012 +0200
4.3 @@ -86,183 +86,179 @@
4.4 return new int[]{visitor.minOffset, visitor.maxOffset};
4.5 }
4.6
4.7 - private static class OffsetFinder extends com.oracle.nashorn.ir.NodeVisitor {
4.8 + private static class OffsetFinder extends com.oracle.nashorn.ir.visitor.NodeVisitor {
4.9 protected int minOffset = Integer.MAX_VALUE;
4.10 protected int maxOffset = -1;
4.11
4.12 - private Node findOffsets(Node node, boolean onset) {
4.13 - if(onset) {
4.14 - int min = node.position();
4.15 - int max = min + node.length();
4.16 - if (minOffset > min) {
4.17 - minOffset = min;
4.18 - }
4.19 - if (maxOffset < max) {
4.20 - maxOffset = max;
4.21 - }
4.22 - }
4.23 + private Node findOffsets(Node node) {
4.24 + int min = node.position();
4.25 + int max = min + node.length();
4.26 + if (minOffset > min) {
4.27 + minOffset = min;
4.28 + }
4.29 + if (maxOffset < max) {
4.30 + maxOffset = max;
4.31 + }
4.32 return node;
4.33
4.34 }
4.35
4.36 @Override
4.37 - public Node visit(AccessNode accessNode, boolean onset) {
4.38 - return findOffsets(accessNode, onset);
4.39 + public Node enter(AccessNode accessNode) {
4.40 + return findOffsets(accessNode);
4.41 }
4.42
4.43 @Override
4.44 - public Node visit(BinaryNode binaryNode, boolean onset) {
4.45 - return findOffsets(binaryNode, onset);
4.46 + public Node enter(BinaryNode binaryNode) {
4.47 + return findOffsets(binaryNode);
4.48 }
4.49
4.50 @Override
4.51 - public Node visit(Block block, boolean onset) {
4.52 - return findOffsets(block, onset);
4.53 + public Node enter(Block block) {
4.54 + return findOffsets(block);
4.55 }
4.56
4.57 @Override
4.58 - public Node visit(BreakNode breakNode, boolean onset) {
4.59 - return findOffsets(breakNode, onset);
4.60 + public Node enter(BreakNode breakNode) {
4.61 + return findOffsets(breakNode);
4.62 }
4.63
4.64 @Override
4.65 - public Node visit(CallNode callNode, boolean onset) {
4.66 - return findOffsets(callNode, onset);
4.67 + public Node enter(CallNode callNode) {
4.68 + return findOffsets(callNode);
4.69 }
4.70
4.71 @Override
4.72 - public Node visit(CaseNode caseNode, boolean onset) {
4.73 - return findOffsets(caseNode, onset);
4.74 + public Node enter(CaseNode caseNode) {
4.75 + return findOffsets(caseNode);
4.76 }
4.77
4.78 @Override
4.79 - public Node visit(CatchNode catchNode, boolean onset) {
4.80 - return findOffsets(catchNode, onset);
4.81 + public Node enter(CatchNode catchNode) {
4.82 + return findOffsets(catchNode);
4.83 }
4.84
4.85 @Override
4.86 - public Node visit(ContinueNode continueNode, boolean onset) {
4.87 - return findOffsets(continueNode, onset);
4.88 + public Node enter(ContinueNode continueNode) {
4.89 + return findOffsets(continueNode);
4.90 }
4.91
4.92 @Override
4.93 - public Node visit(ExecuteNode executeNode, boolean onset) {
4.94 - return findOffsets(executeNode, onset);
4.95 + public Node enter(ExecuteNode executeNode) {
4.96 + return findOffsets(executeNode);
4.97 }
4.98
4.99 @Override
4.100 - public Node visit(ForNode forNode, boolean onset) {
4.101 - return findOffsets(forNode, onset);
4.102 + public Node enter(ForNode forNode) {
4.103 + return findOffsets(forNode);
4.104 }
4.105
4.106 @Override
4.107 - public Node visit(FunctionNode functionNode, boolean onset) {
4.108 - if (onset) {
4.109 - int min = Token.descPosition(functionNode.getFirstToken());
4.110 - int max = Token.descPosition(functionNode.getLastToken()) + Token.descLength(functionNode.getLastToken());
4.111 - if (minOffset > min) {
4.112 - minOffset = min;
4.113 - }
4.114 - if (maxOffset < max) {
4.115 - maxOffset = max;
4.116 - }
4.117 + public Node enter(FunctionNode functionNode) {
4.118 + int min = Token.descPosition(functionNode.getFirstToken());
4.119 + int max = Token.descPosition(functionNode.getLastToken()) + Token.descLength(functionNode.getLastToken());
4.120 + if (minOffset > min) {
4.121 + minOffset = min;
4.122 }
4.123 - return findOffsets(functionNode, onset);
4.124 + if (maxOffset < max) {
4.125 + maxOffset = max;
4.126 + }
4.127 + return findOffsets(functionNode);
4.128 }
4.129
4.130 @Override
4.131 - public Node visit(IdentNode identNode, boolean onset) {
4.132 - return findOffsets(identNode, onset);
4.133 + public Node enter(IdentNode identNode) {
4.134 + return findOffsets(identNode);
4.135 }
4.136
4.137 @Override
4.138 - public Node visit(IfNode ifNode, boolean onset) {
4.139 - return findOffsets(ifNode, onset);
4.140 + public Node enter(IfNode ifNode) {
4.141 + return findOffsets(ifNode);
4.142 }
4.143
4.144 @Override
4.145 - public Node visit(IndexNode indexNode, boolean onset) {
4.146 - return findOffsets(indexNode, onset);
4.147 + public Node enter(IndexNode indexNode) {
4.148 + return findOffsets(indexNode);
4.149 }
4.150
4.151 @Override
4.152 - public Node visit(LabelNode labeledNode, boolean onset) {
4.153 - return findOffsets(labeledNode, onset);
4.154 + public Node enter(LabelNode labeledNode) {
4.155 + return findOffsets(labeledNode);
4.156 }
4.157
4.158 @Override
4.159 - public Node visit(LineNumberNode lineNumberNode, boolean onset) {
4.160 - return findOffsets(lineNumberNode, onset);
4.161 + public Node enter(LineNumberNode lineNumberNode) {
4.162 + return findOffsets(lineNumberNode);
4.163 }
4.164
4.165 @Override
4.166 - public Node visit(LiteralNode literalNode, boolean onset) {
4.167 - return findOffsets(literalNode, onset);
4.168 + public Node enter(LiteralNode literalNode) {
4.169 + return findOffsets(literalNode);
4.170 }
4.171
4.172 @Override
4.173 - public Node visit(ObjectNode objectNode, boolean onset) {
4.174 - return findOffsets(objectNode, onset);
4.175 + public Node enter(ObjectNode objectNode) {
4.176 + return findOffsets(objectNode);
4.177 }
4.178
4.179 @Override
4.180 - public Node visit(PropertyNode propertyNode, boolean onset) {
4.181 - return findOffsets(propertyNode, onset);
4.182 + public Node enter(PropertyNode propertyNode) {
4.183 + return findOffsets(propertyNode);
4.184 }
4.185
4.186 @Override
4.187 - public Node visit(ReferenceNode referenceNode, boolean onset) {
4.188 - return findOffsets(referenceNode, onset);
4.189 + public Node enter(ReferenceNode referenceNode) {
4.190 + return findOffsets(referenceNode);
4.191 }
4.192
4.193 @Override
4.194 - public Node visit(ReturnNode returnNode, boolean onset) {
4.195 - return findOffsets(returnNode, onset);
4.196 + public Node enter(ReturnNode returnNode) {
4.197 + return findOffsets(returnNode);
4.198 }
4.199
4.200 @Override
4.201 - public Node visit(RuntimeNode runtimeNode, boolean onset) {
4.202 - return findOffsets(runtimeNode, onset);
4.203 + public Node enter(RuntimeNode runtimeNode) {
4.204 + return findOffsets(runtimeNode);
4.205 }
4.206
4.207 @Override
4.208 - public Node visit(SwitchNode switchNode, boolean onset) {
4.209 - return findOffsets(switchNode, onset);
4.210 + public Node enter(SwitchNode switchNode) {
4.211 + return findOffsets(switchNode);
4.212 }
4.213
4.214 @Override
4.215 - public Node visit(TernaryNode ternaryNode, boolean onset) {
4.216 - return findOffsets(ternaryNode, onset);
4.217 + public Node enter(TernaryNode ternaryNode) {
4.218 + return findOffsets(ternaryNode);
4.219 }
4.220
4.221 @Override
4.222 - public Node visit(ThrowNode throwNode, boolean onset) {
4.223 - return findOffsets(throwNode, onset);
4.224 + public Node enter(ThrowNode throwNode) {
4.225 + return findOffsets(throwNode);
4.226 }
4.227
4.228 @Override
4.229 - public Node visit(TryNode tryNode, boolean onset) {
4.230 - return findOffsets(tryNode, onset);
4.231 + public Node enter(TryNode tryNode) {
4.232 + return findOffsets(tryNode);
4.233 }
4.234
4.235 @Override
4.236 - public Node visit(UnaryNode unaryNode, boolean onset) {
4.237 - return findOffsets(unaryNode, onset);
4.238 + public Node enter(UnaryNode unaryNode) {
4.239 + return findOffsets(unaryNode);
4.240 }
4.241
4.242 @Override
4.243 - public Node visit(VarNode varNode, boolean onset) {
4.244 - return findOffsets(varNode, onset);
4.245 + public Node enter(VarNode varNode) {
4.246 + return findOffsets(varNode);
4.247 }
4.248
4.249 @Override
4.250 - public Node visit(WhileNode whileNode, boolean onset) {
4.251 - return findOffsets(whileNode, onset);
4.252 + public Node enter(WhileNode whileNode) {
4.253 + return findOffsets(whileNode);
4.254 }
4.255
4.256 @Override
4.257 - public Node visit(WithNode withNode, boolean onset) {
4.258 - return findOffsets(withNode, onset);
4.259 + public Node enter(WithNode withNode) {
4.260 + return findOffsets(withNode);
4.261 }
4.262
4.263
5.1 --- a/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/ScannerVisitor.java Wed Sep 12 10:06:17 2012 +0200
5.2 +++ b/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/ScannerVisitor.java Wed Sep 12 17:19:28 2012 +0200
5.3 @@ -55,7 +55,6 @@
5.4 import com.oracle.nashorn.ir.LineNumberNode;
5.5 import com.oracle.nashorn.ir.LiteralNode;
5.6 import com.oracle.nashorn.ir.Node;
5.7 -import com.oracle.nashorn.ir.NodeVisitor;
5.8 import com.oracle.nashorn.ir.ObjectNode;
5.9 import com.oracle.nashorn.ir.PropertyNode;
5.10 import com.oracle.nashorn.ir.ReferenceNode;
5.11 @@ -69,171 +68,324 @@
5.12 import com.oracle.nashorn.ir.VarNode;
5.13 import com.oracle.nashorn.ir.WhileNode;
5.14 import com.oracle.nashorn.ir.WithNode;
5.15 -import com.oracle.nashorn.parser.Token;
5.16 +import com.oracle.nashorn.ir.visitor.NodeVisitor;
5.17
5.18 /**
5.19 *
5.20 * @author petr
5.21 */
5.22 -public abstract class ScannerVisitor extends NodeVisitor {
5.23 +public abstract class ScannerVisitor extends NodeVisitor {
5.24
5.25
5.26 public abstract Node scanOnSet(Node node, boolean onset);
5.27
5.28 @Override
5.29 - public Node visit(AccessNode accessNode, boolean onset) {
5.30 - return scanOnSet(accessNode, onset);
5.31 - }
5.32 -
5.33 -
5.34 -
5.35 - @Override
5.36 - public Node visit(BinaryNode iNode, boolean onset) {
5.37 - return scanOnSet(iNode, onset);
5.38 + public Node enter(AccessNode accessNode) {
5.39 + return scanOnSet(accessNode, true);
5.40 }
5.41
5.42 @Override
5.43 - public Node visit(Block block, boolean onset) {
5.44 - return scanOnSet(block, onset);
5.45 + public Node enter(BinaryNode iNode) {
5.46 + return scanOnSet(iNode, true);
5.47 }
5.48
5.49 @Override
5.50 - public Node visit(BreakNode breakNode, boolean onset) {
5.51 - return scanOnSet(breakNode, onset);
5.52 + public Node enter(Block block) {
5.53 + return scanOnSet(block, true);
5.54 }
5.55
5.56 @Override
5.57 - public Node visit(CallNode callNode, boolean onset) {
5.58 - return scanOnSet(callNode, onset);
5.59 + public Node enter(BreakNode breakNode) {
5.60 + return scanOnSet(breakNode, true);
5.61 }
5.62
5.63 @Override
5.64 - public Node visit(CaseNode caseNode, boolean onset) {
5.65 - return scanOnSet(caseNode, onset);
5.66 + public Node enter(CallNode callNode) {
5.67 + return scanOnSet(callNode, true);
5.68 }
5.69
5.70 @Override
5.71 - public Node visit(CatchNode catchNode, boolean onset) {
5.72 - return scanOnSet(catchNode, onset);
5.73 + public Node enter(CaseNode caseNode) {
5.74 + return scanOnSet(caseNode, true);
5.75 }
5.76
5.77 @Override
5.78 - public Node visit(ContinueNode continueNode, boolean onset) {
5.79 - return scanOnSet(continueNode, onset);
5.80 + public Node enter(CatchNode catchNode) {
5.81 + return scanOnSet(catchNode, true);
5.82 }
5.83
5.84 @Override
5.85 - public Node visit(ExecuteNode executeNode, boolean onset) {
5.86 - return scanOnSet(executeNode, onset);
5.87 + public Node enter(ContinueNode continueNode) {
5.88 + return scanOnSet(continueNode, true);
5.89 + }
5.90 +
5.91 + @Override
5.92 + public Node enter(ExecuteNode executeNode) {
5.93 + return scanOnSet(executeNode, true);
5.94 }
5.95
5.96 // @Override
5.97 -// public Node visit(ErrorNode iNode, boolean onset) {
5.98 -// return scanOnSet(accessNode, onset);
5.99 +// public Node enter(ErrorNode iNode) {
5.100 +// return scanOnSet(accessNode, true);
5.101 // }
5.102
5.103 @Override
5.104 - public Node visit(ForNode forNode, boolean onset) {
5.105 - return scanOnSet(forNode, onset);
5.106 + public Node enter(ForNode forNode) {
5.107 + return scanOnSet(forNode, true);
5.108 }
5.109
5.110 @Override
5.111 - public Node visit(FunctionNode functionNode, boolean onset) {
5.112 - return scanOnSet(functionNode, onset);
5.113 + public Node enter(FunctionNode functionNode) {
5.114 + return scanOnSet(functionNode, true);
5.115 }
5.116
5.117 @Override
5.118 - public Node visit(IdentNode identNode, boolean onset) {
5.119 - return scanOnSet(identNode, onset);
5.120 + public Node enter(IdentNode identNode) {
5.121 + return scanOnSet(identNode, true);
5.122 }
5.123
5.124 @Override
5.125 - public Node visit(IfNode ifNode, boolean onset) {
5.126 - return scanOnSet(ifNode, onset);
5.127 + public Node enter(IfNode ifNode) {
5.128 + return scanOnSet(ifNode, true);
5.129 }
5.130
5.131 @Override
5.132 - public Node visit(IndexNode indexNode, boolean onset) {
5.133 - return scanOnSet(indexNode, onset);
5.134 + public Node enter(IndexNode indexNode) {
5.135 + return scanOnSet(indexNode, true);
5.136 }
5.137
5.138 @Override
5.139 - public Node visit(LabelNode labeledNode, boolean onset) {
5.140 - return scanOnSet(labeledNode, onset);
5.141 + public Node enter(LabelNode labeledNode) {
5.142 + return scanOnSet(labeledNode, true);
5.143 }
5.144
5.145 @Override
5.146 - public Node visit(LineNumberNode node, boolean onset) {
5.147 - return scanOnSet(node, onset);
5.148 + public Node enter(LineNumberNode node) {
5.149 + return scanOnSet(node, true);
5.150 }
5.151
5.152 @Override
5.153 - public Node visit(LiteralNode literalNode, boolean onset) {
5.154 - return scanOnSet(literalNode, onset);
5.155 + public Node enter(LiteralNode literalNode) {
5.156 + return scanOnSet(literalNode, true);
5.157 }
5.158
5.159 @Override
5.160 - public Node visit(ObjectNode objectNode, boolean onset) {
5.161 - return scanOnSet(objectNode, onset);
5.162 + public Node enter(ObjectNode objectNode) {
5.163 + return scanOnSet(objectNode, true);
5.164 }
5.165
5.166 @Override
5.167 - public Node visit(PropertyNode propertyNode, boolean onset) {
5.168 - return scanOnSet(propertyNode, onset);
5.169 + public Node enter(PropertyNode propertyNode) {
5.170 + return scanOnSet(propertyNode, true);
5.171 }
5.172
5.173 @Override
5.174 - public Node visit(ReferenceNode node, boolean onset) {
5.175 - return scanOnSet(node, onset);
5.176 + public Node enter(ReferenceNode node) {
5.177 + return scanOnSet(node, true);
5.178 }
5.179
5.180 @Override
5.181 - public Node visit(ReturnNode returnNode, boolean onset) {
5.182 - return scanOnSet(returnNode, onset);
5.183 + public Node enter(ReturnNode returnNode) {
5.184 + return scanOnSet(returnNode, true);
5.185 }
5.186
5.187 @Override
5.188 - public Node visit(RuntimeNode runtimeNode, boolean onset) {
5.189 - return scanOnSet(runtimeNode, onset);
5.190 + public Node enter(RuntimeNode runtimeNode) {
5.191 + return scanOnSet(runtimeNode, true);
5.192 }
5.193
5.194 @Override
5.195 - public Node visit(SwitchNode switchNode, boolean onset) {
5.196 - return scanOnSet(switchNode, onset);
5.197 + public Node enter(SwitchNode switchNode) {
5.198 + return scanOnSet(switchNode, true);
5.199 }
5.200
5.201 @Override
5.202 - public Node visit(TernaryNode ternaryNode, boolean onset) {
5.203 - return scanOnSet(ternaryNode, onset);
5.204 + public Node enter(TernaryNode ternaryNode) {
5.205 + return scanOnSet(ternaryNode, true);
5.206 }
5.207
5.208 @Override
5.209 - public Node visit(ThrowNode throwNode, boolean onset) {
5.210 - return scanOnSet(throwNode, onset);
5.211 + public Node enter(ThrowNode throwNode) {
5.212 + return scanOnSet(throwNode, true);
5.213 }
5.214
5.215 @Override
5.216 - public Node visit(TryNode tryNode, boolean onset) {
5.217 - return scanOnSet(tryNode, onset);
5.218 + public Node enter(TryNode tryNode) {
5.219 + return scanOnSet(tryNode, true);
5.220 }
5.221
5.222 @Override
5.223 - public Node visit(UnaryNode unaryNode, boolean onset) {
5.224 - return scanOnSet(unaryNode, onset);
5.225 + public Node enter(UnaryNode unaryNode) {
5.226 + return scanOnSet(unaryNode, true);
5.227 }
5.228
5.229 @Override
5.230 - public Node visit(VarNode varNode, boolean onset) {
5.231 - return scanOnSet(varNode, onset);
5.232 + public Node enter(VarNode varNode) {
5.233 + return scanOnSet(varNode, true);
5.234 }
5.235
5.236 @Override
5.237 - public Node visit(WhileNode whileNode, boolean onset) {
5.238 - return scanOnSet(whileNode, onset);
5.239 + public Node enter(WhileNode whileNode) {
5.240 + return scanOnSet(whileNode, true);
5.241 }
5.242
5.243 @Override
5.244 - public Node visit(WithNode withNode, boolean onset) {
5.245 - return scanOnSet(withNode, onset);
5.246 + public Node enter(WithNode withNode) {
5.247 + return scanOnSet(withNode, true);
5.248 + }
5.249 +
5.250 + @Override
5.251 + public Node leave(AccessNode accessNode) {
5.252 + return scanOnSet(accessNode, false);
5.253 + }
5.254 +
5.255 + @Override
5.256 + public Node leave(BinaryNode iNode) {
5.257 + return scanOnSet(iNode, false);
5.258 + }
5.259 +
5.260 + @Override
5.261 + public Node leave(Block block) {
5.262 + return scanOnSet(block, false);
5.263 + }
5.264 +
5.265 + @Override
5.266 + public Node leave(BreakNode breakNode) {
5.267 + return scanOnSet(breakNode, false);
5.268 + }
5.269 +
5.270 + @Override
5.271 + public Node leave(CallNode callNode) {
5.272 + return scanOnSet(callNode, false);
5.273 + }
5.274 +
5.275 + @Override
5.276 + public Node leave(CaseNode caseNode) {
5.277 + return scanOnSet(caseNode, false);
5.278 + }
5.279 +
5.280 + @Override
5.281 + public Node leave(CatchNode catchNode) {
5.282 + return scanOnSet(catchNode, false);
5.283 + }
5.284 +
5.285 + @Override
5.286 + public Node leave(ContinueNode continueNode) {
5.287 + return scanOnSet(continueNode, false);
5.288 + }
5.289 +
5.290 + @Override
5.291 + public Node leave(ExecuteNode executeNode) {
5.292 + return scanOnSet(executeNode, false);
5.293 + }
5.294 +
5.295 +// @Override
5.296 +// public Node leave(ErrorNode iNode) {
5.297 +// return scanOnSet(accessNode, false);
5.298 +// }
5.299 +
5.300 + @Override
5.301 + public Node leave(ForNode forNode) {
5.302 + return scanOnSet(forNode, false);
5.303 + }
5.304 +
5.305 + @Override
5.306 + public Node leave(FunctionNode functionNode) {
5.307 + return scanOnSet(functionNode, false);
5.308 + }
5.309 +
5.310 + @Override
5.311 + public Node leave(IdentNode identNode) {
5.312 + return scanOnSet(identNode, false);
5.313 + }
5.314 +
5.315 + @Override
5.316 + public Node leave(IfNode ifNode) {
5.317 + return scanOnSet(ifNode, false);
5.318 + }
5.319 +
5.320 + @Override
5.321 + public Node leave(IndexNode indexNode) {
5.322 + return scanOnSet(indexNode, false);
5.323 + }
5.324 +
5.325 + @Override
5.326 + public Node leave(LabelNode labeledNode) {
5.327 + return scanOnSet(labeledNode, false);
5.328 + }
5.329 +
5.330 + @Override
5.331 + public Node leave(LineNumberNode node) {
5.332 + return scanOnSet(node, false);
5.333 + }
5.334 +
5.335 + @Override
5.336 + public Node leave(LiteralNode literalNode) {
5.337 + return scanOnSet(literalNode, false);
5.338 + }
5.339 +
5.340 + @Override
5.341 + public Node leave(ObjectNode objectNode) {
5.342 + return scanOnSet(objectNode, false);
5.343 + }
5.344 +
5.345 + @Override
5.346 + public Node leave(PropertyNode propertyNode) {
5.347 + return scanOnSet(propertyNode, false);
5.348 + }
5.349 +
5.350 + @Override
5.351 + public Node leave(ReferenceNode node) {
5.352 + return scanOnSet(node, false);
5.353 + }
5.354 +
5.355 + @Override
5.356 + public Node leave(ReturnNode returnNode) {
5.357 + return scanOnSet(returnNode, false);
5.358 + }
5.359 +
5.360 + @Override
5.361 + public Node leave(RuntimeNode runtimeNode) {
5.362 + return scanOnSet(runtimeNode, false);
5.363 + }
5.364 +
5.365 + @Override
5.366 + public Node leave(SwitchNode switchNode) {
5.367 + return scanOnSet(switchNode, false);
5.368 + }
5.369 +
5.370 + @Override
5.371 + public Node leave(TernaryNode ternaryNode) {
5.372 + return scanOnSet(ternaryNode, false);
5.373 + }
5.374 +
5.375 + @Override
5.376 + public Node leave(ThrowNode throwNode) {
5.377 + return scanOnSet(throwNode, false);
5.378 + }
5.379 +
5.380 + @Override
5.381 + public Node leave(TryNode tryNode) {
5.382 + return scanOnSet(tryNode, false);
5.383 + }
5.384 +
5.385 + @Override
5.386 + public Node leave(UnaryNode unaryNode) {
5.387 + return scanOnSet(unaryNode, false);
5.388 + }
5.389 +
5.390 + @Override
5.391 + public Node leave(VarNode varNode) {
5.392 + return scanOnSet(varNode, false);
5.393 + }
5.394 +
5.395 + @Override
5.396 + public Node leave(WhileNode whileNode) {
5.397 + return scanOnSet(whileNode, false);
5.398 + }
5.399 +
5.400 + @Override
5.401 + public Node leave(WithNode withNode) {
5.402 + return scanOnSet(withNode, false);
5.403 }
5.404 }
6.1 --- a/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/SimpleTreeNodeVisitor.java Wed Sep 12 10:06:17 2012 +0200
6.2 +++ b/javascript.devtools/src/org/netbeans/modules/javascript/devtools/astbrowser/SimpleTreeNodeVisitor.java Wed Sep 12 17:19:28 2012 +0200
6.3 @@ -55,7 +55,6 @@
6.4 import com.oracle.nashorn.ir.LineNumberNode;
6.5 import com.oracle.nashorn.ir.LiteralNode;
6.6 import com.oracle.nashorn.ir.Node;
6.7 -import com.oracle.nashorn.ir.NodeVisitor;
6.8 import com.oracle.nashorn.ir.ObjectNode;
6.9 import com.oracle.nashorn.ir.PropertyNode;
6.10 import com.oracle.nashorn.ir.ReferenceNode;
6.11 @@ -69,6 +68,7 @@
6.12 import com.oracle.nashorn.ir.VarNode;
6.13 import com.oracle.nashorn.ir.WhileNode;
6.14 import com.oracle.nashorn.ir.WithNode;
6.15 +import com.oracle.nashorn.ir.visitor.NodeVisitor;
6.16 import com.oracle.nashorn.parser.Token;
6.17 import java.util.ArrayList;
6.18 import java.util.List;
6.19 @@ -127,66 +127,106 @@
6.20
6.21
6.22 @Override
6.23 - public Node visit(AccessNode accessNode, boolean onset) {
6.24 - return notComplete(accessNode, onset);
6.25 + public Node enter(AccessNode accessNode) {
6.26 + return notComplete(accessNode, true);
6.27 }
6.28
6.29 @Override
6.30 - public Node visit(BinaryNode iNode, boolean onset) {
6.31 - if (onset) {
6.32 + public Node leave(AccessNode accessNode) {
6.33 + return notComplete(accessNode, false);
6.34 + }
6.35 +
6.36 + @Override
6.37 + public Node enter(BinaryNode iNode) {
6.38 // int[] offsets = OffsetUtils.getOffsets(iNode);
6.39 - int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
6.40 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.41 - iNode.getClass().getSimpleName() + " " + iNode.tokenType().getName(),
6.42 - offsets[0], offsets[1]);
6.43 - parentNode.addChild(adapter);
6.44 - parents.add(parentNode);
6.45 - parentNode = adapter;
6.46 -
6.47 - } else {
6.48 - parentNode = parents.remove(parents.size() - 1);
6.49 -
6.50 - }
6.51 + int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
6.52 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.53 + iNode.getClass().getSimpleName() + " " + iNode.tokenType().getName(),
6.54 + offsets[0], offsets[1]);
6.55 + parentNode.addChild(adapter);
6.56 + parents.add(parentNode);
6.57 + parentNode = adapter;
6.58 return iNode;
6.59 }
6.60
6.61 @Override
6.62 - public Node visit(Block block, boolean onset) {
6.63 - return notComplete(block, onset);
6.64 + public Node leave(BinaryNode iNode) {
6.65 + parentNode = parents.remove(parents.size() - 1);
6.66 + return iNode;
6.67 }
6.68
6.69 @Override
6.70 - public Node visit(BreakNode breakNode, boolean onset) {
6.71 - return notComplete(breakNode, onset);
6.72 + public Node enter(Block block) {
6.73 + return notComplete(block, true);
6.74 }
6.75
6.76 @Override
6.77 - public Node visit(CallNode callNode, boolean onset) {
6.78 - return notComplete(callNode, onset);
6.79 + public Node leave(Block block) {
6.80 + return notComplete(block, false);
6.81 }
6.82
6.83 @Override
6.84 - public Node visit(CaseNode caseNode, boolean onset) {
6.85 - return notComplete(caseNode, onset);
6.86 + public Node enter(BreakNode breakNode) {
6.87 + return notComplete(breakNode, true);
6.88 }
6.89
6.90 @Override
6.91 - public Node visit(CatchNode catchNode, boolean onset) {
6.92 - return notComplete(catchNode, onset);
6.93 + public Node leave(BreakNode breakNode) {
6.94 + return notComplete(breakNode, false);
6.95 }
6.96
6.97 @Override
6.98 - public Node visit(ContinueNode continueNode, boolean onset) {
6.99 - return notComplete(continueNode, onset);
6.100 + public Node enter(CallNode callNode) {
6.101 + return notComplete(callNode, true);
6.102 }
6.103
6.104 @Override
6.105 - public Node visit(ExecuteNode executeNode, boolean onset) {
6.106 - return notComplete(executeNode, onset);
6.107 + public Node leave(CallNode callNode) {
6.108 + return notComplete(callNode, false);
6.109 + }
6.110 +
6.111 + @Override
6.112 + public Node enter(CaseNode caseNode) {
6.113 + return notComplete(caseNode, true);
6.114 + }
6.115 +
6.116 + @Override
6.117 + public Node leave(CaseNode caseNode) {
6.118 + return notComplete(caseNode, false);
6.119 + }
6.120 +
6.121 + @Override
6.122 + public Node enter(CatchNode catchNode) {
6.123 + return notComplete(catchNode, true);
6.124 + }
6.125 +
6.126 + @Override
6.127 + public Node leave(CatchNode catchNode) {
6.128 + return notComplete(catchNode, false);
6.129 + }
6.130 +
6.131 + @Override
6.132 + public Node enter(ContinueNode continueNode) {
6.133 + return notComplete(continueNode, true);
6.134 + }
6.135 +
6.136 + @Override
6.137 + public Node leave(ContinueNode continueNode) {
6.138 + return notComplete(continueNode, false);
6.139 + }
6.140 +
6.141 + @Override
6.142 + public Node enter(ExecuteNode executeNode) {
6.143 + return notComplete(executeNode, true);
6.144 + }
6.145 +
6.146 + @Override
6.147 + public Node leave(ExecuteNode executeNode) {
6.148 + return notComplete(executeNode, false);
6.149 }
6.150
6.151 // @Override
6.152 -// public Node visit(ErrorNode iNode, boolean onset) {
6.153 +// public Node enter(ErrorNode iNode) {
6.154 // if (onset) {
6.155 // int[] offsets = new int[]{iNode.getStart(), iNode.getFinish()};
6.156 // TreeASTNodeAdapter adapter = new TreeASTNodeAdapter(parentNode,
6.157 @@ -207,160 +247,252 @@
6.158
6.159
6.160 @Override
6.161 - public Node visit(ForNode forNode, boolean onset) {
6.162 - return notComplete(forNode, onset);
6.163 + public Node enter(ForNode forNode) {
6.164 + return notComplete(forNode, true);
6.165 + }
6.166 + @Override
6.167 + public Node leave(ForNode forNode) {
6.168 + return notComplete(forNode, false);
6.169 }
6.170
6.171 @Override
6.172 - public Node visit(FunctionNode functionNode, boolean onset) {
6.173 - if (onset) {
6.174 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.175 - functionNode.getClass().getSimpleName() + " <b>" + functionNode.getName() + "</b>",
6.176 - "<html>Name: " + functionNode.getName() +"<br/>"
6.177 - + "Kind: " + functionNode.getKind().toString() +"<br/>"
6.178 - + "</html>",
6.179 - Token.descPosition(functionNode.getFirstToken()), Token.descPosition(functionNode.getLastToken()) + Token.descLength(functionNode.getLastToken()));
6.180 - //(int)functionNode.position(), (int)(functionNode.position() + functionNode.length()));
6.181 - parentNode.addChild(adapter);
6.182 - parents.add(parentNode);
6.183 - parentNode = adapter;
6.184 + public Node enter(FunctionNode functionNode) {
6.185 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.186 + functionNode.getClass().getSimpleName() + " <b>" + functionNode.getName() + "</b>",
6.187 + "<html>Name: " + functionNode.getName() +"<br/>"
6.188 + + "Kind: " + functionNode.getKind().toString() +"<br/>"
6.189 + + "</html>",
6.190 + Token.descPosition(functionNode.getFirstToken()), Token.descPosition(functionNode.getLastToken()) + Token.descLength(functionNode.getLastToken()));
6.191 + //(int)functionNode.position(), (int)(functionNode.position() + functionNode.length()));
6.192 + parentNode.addChild(adapter);
6.193 + parents.add(parentNode);
6.194 + parentNode = adapter;
6.195 // parentNode.addChild(new TreeASTNodeAdapter(parentNode,
6.196 // "Name: " + functionNode.getName(),
6.197 // 0,0));
6.198 - } else {
6.199 - parentNode = parents.remove(parents.size() - 1);
6.200 - }
6.201 return functionNode;
6.202 }
6.203
6.204 @Override
6.205 - public Node visit(IdentNode identNode, boolean onset) {
6.206 - if (onset) {
6.207 - int[] offsets = new int[]{identNode.getStart(), identNode.getFinish()};
6.208 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.209 - identNode.getClass().getSimpleName() + " <b>" + identNode.getName() + "</b>",
6.210 - offsets[0], offsets[1]);
6.211 - parentNode.addChild(adapter);
6.212 - parents.add(parentNode);
6.213 - parentNode = adapter;
6.214 -// return super.visit(identNode, onset);
6.215 - } else {
6.216 - parentNode = parents.remove(parents.size() - 1);
6.217 -// return null;
6.218 - }
6.219 + public Node leave(FunctionNode functionNode) {
6.220 + parentNode = parents.remove(parents.size() - 1);
6.221 + return functionNode;
6.222 + }
6.223 +
6.224 + @Override
6.225 + public Node enter(IdentNode identNode) {
6.226 + int[] offsets = new int[]{identNode.getStart(), identNode.getFinish()};
6.227 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.228 + identNode.getClass().getSimpleName() + " <b>" + identNode.getName() + "</b>",
6.229 + offsets[0], offsets[1]);
6.230 + parentNode.addChild(adapter);
6.231 + parents.add(parentNode);
6.232 + parentNode = adapter;
6.233 +// return super.visit(identNode, true);
6.234 return identNode;
6.235 }
6.236
6.237 @Override
6.238 - public Node visit(IfNode ifNode, boolean onset) {
6.239 - return notComplete(ifNode, onset);
6.240 + public Node leave(IdentNode identNode) {
6.241 + parentNode = parents.remove(parents.size() - 1);
6.242 + return identNode;
6.243 }
6.244
6.245 @Override
6.246 - public Node visit(IndexNode indexNode, boolean onset) {
6.247 - return notComplete(indexNode, onset);
6.248 + public Node enter(IfNode ifNode) {
6.249 + return notComplete(ifNode, true);
6.250 }
6.251
6.252 @Override
6.253 - public Node visit(LabelNode labeledNode, boolean onset) {
6.254 - return notComplete(labeledNode, onset);
6.255 + public Node leave(IfNode ifNode) {
6.256 + return notComplete(ifNode, false);
6.257 }
6.258
6.259 @Override
6.260 - public Node visit(LineNumberNode node, boolean onset) {
6.261 - return visitSimpleNode(node, "", "Line number: " + node.getLineNumber(), onset);
6.262 + public Node enter(IndexNode indexNode) {
6.263 + return notComplete(indexNode, true);
6.264 }
6.265
6.266 @Override
6.267 - public Node visit(LiteralNode literalNode, boolean onset) {
6.268 - return notComplete(literalNode, onset);
6.269 + public Node leave(IndexNode indexNode) {
6.270 + return notComplete(indexNode, false);
6.271 }
6.272
6.273 @Override
6.274 - public Node visit(ObjectNode objectNode, boolean onset) {
6.275 - return notComplete(objectNode, onset);
6.276 + public Node enter(LabelNode labeledNode) {
6.277 + return notComplete(labeledNode, true);
6.278 }
6.279
6.280 @Override
6.281 - public Node visit(PropertyNode propertyNode, boolean onset) {
6.282 - return notComplete(propertyNode, onset);
6.283 + public Node leave(LabelNode labeledNode) {
6.284 + return notComplete(labeledNode, false);
6.285 }
6.286
6.287 @Override
6.288 - public Node visit(ReferenceNode node, boolean onset) {
6.289 - if (onset) {
6.290 - int[] offsets = OffsetUtils.getOffsets(node);
6.291 - TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.292 - node.getClass().getSimpleName(),
6.293 - offsets[0], offsets[1]);
6.294 - parentNode.addChild(adapter);
6.295 - parents.add(parentNode);
6.296 - parentNode = adapter;
6.297 - Object ref = node.getReference();
6.298 - if (ref != null) {
6.299 - if (ref instanceof FunctionNode) {
6.300 - //((FunctionNode)ref).accept(this);
6.301 - }
6.302 - else
6.303 - adapter.addChild(new TreeCreator.TreeASTNodeAdapter(parentNode,
6.304 - "<font color='gray'>" + ref.getClass().getSimpleName() + "</font>"));
6.305 + public Node enter(LineNumberNode node) {
6.306 + return visitSimpleNode(node, "", "Line number: " + node.getLineNumber(), true);
6.307 + }
6.308 +
6.309 + @Override
6.310 + public Node leave(LineNumberNode node) {
6.311 + return visitSimpleNode(node, "", "Line number: " + node.getLineNumber(), true);
6.312 + }
6.313 +
6.314 + @Override
6.315 + public Node enter(LiteralNode literalNode) {
6.316 + return notComplete(literalNode, true);
6.317 + }
6.318 +
6.319 + @Override
6.320 + public Node leave(LiteralNode literalNode) {
6.321 + return notComplete(literalNode, false);
6.322 + }
6.323 +
6.324 + @Override
6.325 + public Node enter(ObjectNode objectNode) {
6.326 + return notComplete(objectNode, true);
6.327 + }
6.328 +
6.329 + @Override
6.330 + public Node leave(ObjectNode objectNode) {
6.331 + return notComplete(objectNode, false);
6.332 + }
6.333 +
6.334 + @Override
6.335 + public Node enter(PropertyNode propertyNode) {
6.336 + return notComplete(propertyNode, true);
6.337 + }
6.338 +
6.339 + @Override
6.340 + public Node leave(PropertyNode propertyNode) {
6.341 + return notComplete(propertyNode, false);
6.342 + }
6.343 +
6.344 + @Override
6.345 + public Node enter(ReferenceNode node) {
6.346 + int[] offsets = OffsetUtils.getOffsets(node);
6.347 + TreeCreator.TreeASTNodeAdapter adapter = new TreeCreator.TreeASTNodeAdapter(parentNode,
6.348 + node.getClass().getSimpleName(),
6.349 + offsets[0], offsets[1]);
6.350 + parentNode.addChild(adapter);
6.351 + parents.add(parentNode);
6.352 + parentNode = adapter;
6.353 + Object ref = node.getReference();
6.354 + if (ref != null) {
6.355 + if (ref instanceof FunctionNode) {
6.356 + //((FunctionNode)ref).accept(this);
6.357 }
6.358 -// return node;
6.359 - } else {
6.360 - parentNode = parents.remove(parents.size() - 1);
6.361 -// return null;
6.362 + else
6.363 + adapter.addChild(new TreeCreator.TreeASTNodeAdapter(parentNode,
6.364 + "<font color='gray'>" + ref.getClass().getSimpleName() + "</font>"));
6.365 }
6.366 return node;
6.367 }
6.368
6.369 @Override
6.370 - public Node visit(ReturnNode returnNode, boolean onset) {
6.371 - return notComplete(returnNode, onset);
6.372 + public Node leave(ReferenceNode node) {
6.373 + parentNode = parents.remove(parents.size() - 1);
6.374 + return node;
6.375 }
6.376
6.377 @Override
6.378 - public Node visit(RuntimeNode runtimeNode, boolean onset) {
6.379 - return notComplete(runtimeNode, onset);
6.380 + public Node enter(ReturnNode returnNode) {
6.381 + return notComplete(returnNode, true);
6.382 }
6.383
6.384 @Override
6.385 - public Node visit(SwitchNode switchNode, boolean onset) {
6.386 - return notComplete(switchNode, onset);
6.387 + public Node leave(ReturnNode returnNode) {
6.388 + return notComplete(returnNode, false);
6.389 }
6.390
6.391 @Override
6.392 - public Node visit(TernaryNode ternaryNode, boolean onset) {
6.393 - return notComplete(ternaryNode, onset);
6.394 + public Node enter(RuntimeNode runtimeNode) {
6.395 + return notComplete(runtimeNode, true);
6.396 }
6.397
6.398 @Override
6.399 - public Node visit(ThrowNode throwNode, boolean onset) {
6.400 - return notComplete(throwNode, onset);
6.401 + public Node leave(RuntimeNode runtimeNode) {
6.402 + return notComplete(runtimeNode, false);
6.403 }
6.404
6.405 @Override
6.406 - public Node visit(TryNode tryNode, boolean onset) {
6.407 - return notComplete(tryNode, onset);
6.408 + public Node enter(SwitchNode switchNode) {
6.409 + return notComplete(switchNode, true);
6.410 }
6.411
6.412 @Override
6.413 - public Node visit(UnaryNode unaryNode, boolean onset) {
6.414 - return notComplete(unaryNode, onset);
6.415 + public Node leave(SwitchNode switchNode) {
6.416 + return notComplete(switchNode, false);
6.417 }
6.418
6.419 @Override
6.420 - public Node visit(VarNode varNode, boolean onset) {
6.421 - return notComplete(varNode, onset);
6.422 + public Node enter(TernaryNode ternaryNode) {
6.423 + return notComplete(ternaryNode, true);
6.424 }
6.425
6.426 @Override
6.427 - public Node visit(WhileNode whileNode, boolean onset) {
6.428 - return notComplete(whileNode, onset);
6.429 + public Node leave(TernaryNode ternaryNode) {
6.430 + return notComplete(ternaryNode, false);
6.431 }
6.432
6.433 @Override
6.434 - public Node visit(WithNode withNode, boolean onset) {
6.435 - return notComplete(withNode, onset);
6.436 + public Node enter(ThrowNode throwNode) {
6.437 + return notComplete(throwNode, true);
6.438 + }
6.439 +
6.440 + @Override
6.441 + public Node leave(ThrowNode throwNode) {
6.442 + return notComplete(throwNode, false);
6.443 + }
6.444 +
6.445 + @Override
6.446 + public Node enter(TryNode tryNode) {
6.447 + return notComplete(tryNode, true);
6.448 + }
6.449 +
6.450 + @Override
6.451 + public Node leave(TryNode tryNode) {
6.452 + return notComplete(tryNode, false);
6.453 + }
6.454 +
6.455 + @Override
6.456 + public Node enter(UnaryNode unaryNode) {
6.457 + return notComplete(unaryNode, true);
6.458 + }
6.459 +
6.460 + @Override
6.461 + public Node leave(UnaryNode unaryNode) {
6.462 + return notComplete(unaryNode, false);
6.463 + }
6.464 +
6.465 + @Override
6.466 + public Node enter(VarNode varNode) {
6.467 + return notComplete(varNode, true);
6.468 + }
6.469 +
6.470 + @Override
6.471 + public Node leave(VarNode varNode) {
6.472 + return notComplete(varNode, false);
6.473 + }
6.474 +
6.475 + @Override
6.476 + public Node enter(WhileNode whileNode) {
6.477 + return notComplete(whileNode, true);
6.478 + }
6.479 +
6.480 + @Override
6.481 + public Node leave(WhileNode whileNode) {
6.482 + return notComplete(whileNode, false);
6.483 + }
6.484 +
6.485 + @Override
6.486 + public Node enter(WithNode withNode) {
6.487 + return notComplete(withNode, true);
6.488 + }
6.489 +
6.490 + @Override
6.491 + public Node leave(WithNode withNode) {
6.492 + return notComplete(withNode, false);
6.493 }
6.494
6.495 }