Mercurial > hg > graal-compiler
annotate graal/com.oracle.truffle.ruby.parser/src/com/oracle/truffle/ruby/parser/Translator.java @ 13918:22bf5a8ba9eb
Ruby: restore prototype debugger.
| author | Chris Seaton <chris.seaton@oracle.com> |
|---|---|
| date | Mon, 10 Feb 2014 03:39:21 +0000 |
| parents | 2c1c805153e6 |
| children |
| rev | line source |
|---|---|
| 13514 | 1 /* |
|
13569
1894412de0ed
Ruby: major upgrade in debugging support, mainly for navigation: step, next (passing over calls), return (from enclosing function), etc. Also a few bug fixes.
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13514
diff
changeset
|
2 * Copyright (c) 2013, 2014 Oracle and/or its affiliates. All rights reserved. This |
| 13514 | 3 * code is released under a tri EPL/GPL/LGPL license. You can use it, |
| 4 * redistribute it and/or modify it under the terms of the: | |
| 5 * | |
| 6 * Eclipse Public License version 1.0 | |
| 7 * GNU General Public License version 2 | |
| 8 * GNU Lesser General Public License version 2.1 | |
| 9 */ | |
| 10 package com.oracle.truffle.ruby.parser; | |
| 11 | |
| 12 import java.math.*; | |
| 13 import java.util.*; | |
| 14 import java.util.regex.*; | |
| 15 | |
| 16 import com.oracle.truffle.api.*; | |
| 17 import com.oracle.truffle.api.frame.*; | |
| 18 import com.oracle.truffle.api.impl.*; | |
| 19 import com.oracle.truffle.ruby.nodes.*; | |
| 20 import com.oracle.truffle.ruby.nodes.call.*; | |
| 21 import com.oracle.truffle.ruby.nodes.cast.*; | |
| 22 import com.oracle.truffle.ruby.nodes.constants.*; | |
| 23 import com.oracle.truffle.ruby.nodes.control.*; | |
| 24 import com.oracle.truffle.ruby.nodes.core.*; | |
| 25 import com.oracle.truffle.ruby.nodes.literal.*; | |
| 26 import com.oracle.truffle.ruby.nodes.literal.array.*; | |
| 27 import com.oracle.truffle.ruby.nodes.methods.*; | |
| 28 import com.oracle.truffle.ruby.nodes.methods.locals.*; | |
| 29 import com.oracle.truffle.ruby.nodes.objects.*; | |
| 30 import com.oracle.truffle.ruby.nodes.objects.instancevariables.*; | |
| 31 import com.oracle.truffle.ruby.nodes.yield.*; | |
| 32 import com.oracle.truffle.ruby.runtime.*; | |
| 33 import com.oracle.truffle.ruby.runtime.core.*; | |
| 34 import com.oracle.truffle.ruby.runtime.core.range.*; | |
| 35 import com.oracle.truffle.ruby.runtime.methods.*; | |
| 36 | |
| 37 /** | |
| 38 * A JRuby parser node visitor which translates JRuby AST nodes into our Ruby nodes, implementing a | |
| 39 * Ruby parser. Therefore there is some namespace contention here! We make all references to JRuby | |
| 40 * explicit. This is the only place though - it doesn't leak out elsewhere. | |
| 41 */ | |
| 42 public class Translator implements org.jrubyparser.NodeVisitor { | |
| 43 | |
| 44 protected final Translator parent; | |
| 45 | |
| 46 protected final RubyContext context; | |
| 47 protected final TranslatorEnvironment environment; | |
| 48 protected final Source source; | |
|
13735
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
49 protected final RubyNodeInstrumenter instrumenter; |
| 13514 | 50 |
| 51 private boolean translatingForStatement = false; | |
| 52 | |
| 53 private static final Map<Class, String> nodeDefinedNames = new HashMap<>(); | |
| 54 | |
| 55 static { | |
| 56 nodeDefinedNames.put(org.jrubyparser.ast.SelfNode.class, "self"); | |
| 57 nodeDefinedNames.put(org.jrubyparser.ast.NilNode.class, "nil"); | |
| 58 nodeDefinedNames.put(org.jrubyparser.ast.TrueNode.class, "true"); | |
| 59 nodeDefinedNames.put(org.jrubyparser.ast.FalseNode.class, "false"); | |
| 60 nodeDefinedNames.put(org.jrubyparser.ast.LocalAsgnNode.class, "assignment"); | |
| 61 nodeDefinedNames.put(org.jrubyparser.ast.DAsgnNode.class, "assignment"); | |
| 62 nodeDefinedNames.put(org.jrubyparser.ast.GlobalAsgnNode.class, "assignment"); | |
| 63 nodeDefinedNames.put(org.jrubyparser.ast.InstAsgnNode.class, "assignment"); | |
| 64 nodeDefinedNames.put(org.jrubyparser.ast.ClassVarAsgnNode.class, "assignment"); | |
| 65 nodeDefinedNames.put(org.jrubyparser.ast.OpAsgnAndNode.class, "assignment"); | |
| 66 nodeDefinedNames.put(org.jrubyparser.ast.OpAsgnOrNode.class, "assignment"); | |
| 67 nodeDefinedNames.put(org.jrubyparser.ast.OpAsgnNode.class, "assignment"); | |
| 68 nodeDefinedNames.put(org.jrubyparser.ast.OpElementAsgnNode.class, "assignment"); | |
| 69 nodeDefinedNames.put(org.jrubyparser.ast.MultipleAsgnNode.class, "assignment"); | |
| 70 nodeDefinedNames.put(org.jrubyparser.ast.GlobalVarNode.class, "global-variable"); | |
| 71 nodeDefinedNames.put(org.jrubyparser.ast.StrNode.class, "expression"); | |
| 72 nodeDefinedNames.put(org.jrubyparser.ast.DStrNode.class, "expression"); | |
| 73 nodeDefinedNames.put(org.jrubyparser.ast.FixnumNode.class, "expression"); | |
| 74 nodeDefinedNames.put(org.jrubyparser.ast.BignumNode.class, "expression"); | |
| 75 nodeDefinedNames.put(org.jrubyparser.ast.FloatNode.class, "expression"); | |
| 76 nodeDefinedNames.put(org.jrubyparser.ast.RegexpNode.class, "expression"); | |
| 77 nodeDefinedNames.put(org.jrubyparser.ast.DRegexpNode.class, "expression"); | |
| 78 nodeDefinedNames.put(org.jrubyparser.ast.ArrayNode.class, "expression"); | |
| 79 nodeDefinedNames.put(org.jrubyparser.ast.HashNode.class, "expression"); | |
| 80 nodeDefinedNames.put(org.jrubyparser.ast.SymbolNode.class, "expression"); | |
| 81 nodeDefinedNames.put(org.jrubyparser.ast.DotNode.class, "expression"); | |
| 82 nodeDefinedNames.put(org.jrubyparser.ast.NotNode.class, "expression"); | |
| 83 nodeDefinedNames.put(org.jrubyparser.ast.AndNode.class, "expression"); | |
| 84 nodeDefinedNames.put(org.jrubyparser.ast.OrNode.class, "expression"); | |
| 85 nodeDefinedNames.put(org.jrubyparser.ast.LocalVarNode.class, "local-variable"); | |
| 86 nodeDefinedNames.put(org.jrubyparser.ast.DVarNode.class, "local-variable"); | |
| 87 } | |
| 88 | |
| 89 /** | |
| 90 * Global variables which in common usage have frame local semantics. | |
| 91 */ | |
| 92 public static final Set<String> FRAME_LOCAL_GLOBAL_VARIABLES = new HashSet<>(Arrays.asList("$_")); | |
| 93 | |
| 94 public Translator(RubyContext context, Translator parent, TranslatorEnvironment environment, Source source) { | |
| 95 this.context = context; | |
| 96 this.parent = parent; | |
| 97 this.environment = environment; | |
| 98 this.source = source; | |
|
13735
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
99 this.instrumenter = environment.getNodeInstrumenter(); |
| 13514 | 100 } |
| 101 | |
| 102 @Override | |
| 103 public Object visitAliasNode(org.jrubyparser.ast.AliasNode node) { | |
| 104 final SourceSection sourceSection = translate(node.getPosition()); | |
| 105 | |
| 106 final org.jrubyparser.ast.LiteralNode oldName = (org.jrubyparser.ast.LiteralNode) node.getOldName(); | |
| 107 final org.jrubyparser.ast.LiteralNode newName = (org.jrubyparser.ast.LiteralNode) node.getNewName(); | |
| 108 | |
| 109 final ClassNode classNode = new ClassNode(context, sourceSection, new SelfNode(context, sourceSection)); | |
| 110 | |
| 111 return new AliasNode(context, sourceSection, classNode, newName.getName(), oldName.getName()); | |
| 112 } | |
| 113 | |
| 114 @Override | |
| 115 public Object visitAndNode(org.jrubyparser.ast.AndNode node) { | |
| 116 final SourceSection sourceSection = translate(node.getPosition()); | |
| 117 | |
| 118 RubyNode x; | |
| 119 | |
| 120 if (node.getFirst() == null) { | |
| 121 x = new NilNode(context, sourceSection); | |
| 122 } else { | |
| 123 x = (RubyNode) node.getFirst().accept(this); | |
| 124 } | |
| 125 | |
| 126 RubyNode y; | |
| 127 | |
| 128 if (node.getSecond() == null) { | |
| 129 y = new NilNode(context, sourceSection); | |
| 130 } else { | |
| 131 y = (RubyNode) node.getSecond().accept(this); | |
| 132 } | |
| 133 | |
| 134 return AndNodeFactory.create(context, sourceSection, x, y); | |
| 135 } | |
| 136 | |
| 137 @Override | |
| 138 public Object visitArgsCatNode(org.jrubyparser.ast.ArgsCatNode node) { | |
| 139 final List<org.jrubyparser.ast.Node> nodes = new ArrayList<>(); | |
| 140 collectArgsCatNodes(nodes, node); | |
| 141 | |
| 142 final List<RubyNode> translatedNodes = new ArrayList<>(); | |
| 143 | |
| 144 for (org.jrubyparser.ast.Node catNode : nodes) { | |
| 145 translatedNodes.add((RubyNode) catNode.accept(this)); | |
| 146 } | |
| 147 | |
| 148 return new ArrayConcatNode(context, translate(node.getPosition()), translatedNodes.toArray(new RubyNode[translatedNodes.size()])); | |
| 149 } | |
| 150 | |
| 151 // ArgsCatNodes can be nested - this collects them into a flat list of children | |
| 152 private void collectArgsCatNodes(List<org.jrubyparser.ast.Node> nodes, org.jrubyparser.ast.ArgsCatNode node) { | |
| 153 if (node.getFirst() instanceof org.jrubyparser.ast.ArgsCatNode) { | |
| 154 collectArgsCatNodes(nodes, (org.jrubyparser.ast.ArgsCatNode) node.getFirst()); | |
| 155 } else { | |
| 156 nodes.add(node.getFirst()); | |
| 157 } | |
| 158 | |
| 159 if (node.getSecond() instanceof org.jrubyparser.ast.ArgsCatNode) { | |
| 160 collectArgsCatNodes(nodes, (org.jrubyparser.ast.ArgsCatNode) node.getSecond()); | |
| 161 } else { | |
| 162 nodes.add(node.getSecond()); | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 @Override | |
| 167 public Object visitArgsNode(org.jrubyparser.ast.ArgsNode node) { | |
| 168 return unimplemented(node); | |
| 169 } | |
| 170 | |
| 171 @Override | |
| 172 public Object visitArgsPushNode(org.jrubyparser.ast.ArgsPushNode node) { | |
| 173 return new ArrayPushNode(context, translate(node.getPosition()), (RubyNode) node.getFirstNode().accept(this), (RubyNode) node.getSecondNode().accept(this)); | |
| 174 } | |
| 175 | |
| 176 @Override | |
| 177 public Object visitArrayNode(org.jrubyparser.ast.ArrayNode node) { | |
| 178 final List<org.jrubyparser.ast.Node> values = node.childNodes(); | |
| 179 | |
| 180 final RubyNode[] translatedValues = new RubyNode[values.size()]; | |
| 181 | |
| 182 for (int n = 0; n < values.size(); n++) { | |
| 183 translatedValues[n] = (RubyNode) values.get(n).accept(this); | |
| 184 } | |
| 185 | |
| 186 return new UninitialisedArrayLiteralNode(context, translate(node.getPosition()), translatedValues); | |
| 187 } | |
| 188 | |
| 189 @Override | |
| 190 public Object visitAttrAssignNode(org.jrubyparser.ast.AttrAssignNode node) { | |
| 191 return visitAttrAssignNodeExtraArgument(node, null); | |
| 192 } | |
| 193 | |
| 194 /** | |
| 195 * See translateDummyAssignment to understand what this is for. | |
| 196 */ | |
| 197 public RubyNode visitAttrAssignNodeExtraArgument(org.jrubyparser.ast.AttrAssignNode node, RubyNode extraArgument) { | |
| 198 final org.jrubyparser.ast.CallNode callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), node.getReceiver(), node.getName(), node.getArgs()); | |
| 199 return visitCallNodeExtraArgument(callNode, extraArgument); | |
| 200 } | |
| 201 | |
| 202 @Override | |
| 203 public Object visitBackRefNode(org.jrubyparser.ast.BackRefNode node) { | |
| 204 return unimplemented(node); | |
| 205 } | |
| 206 | |
| 207 @Override | |
| 208 public Object visitBeginNode(org.jrubyparser.ast.BeginNode node) { | |
| 209 return node.getBody().accept(this); | |
| 210 } | |
| 211 | |
| 212 @Override | |
| 213 public Object visitBignumNode(org.jrubyparser.ast.BignumNode node) { | |
| 214 return new BignumLiteralNode(context, translate(node.getPosition()), node.getValue()); | |
| 215 } | |
| 216 | |
| 217 @Override | |
| 218 public Object visitBlockArg18Node(org.jrubyparser.ast.BlockArg18Node node) { | |
| 219 return unimplemented(node); | |
| 220 } | |
| 221 | |
| 222 @Override | |
| 223 public Object visitBlockArgNode(org.jrubyparser.ast.BlockArgNode node) { | |
| 224 return unimplemented(node); | |
| 225 } | |
| 226 | |
| 227 @Override | |
| 228 public Object visitBlockNode(org.jrubyparser.ast.BlockNode node) { | |
| 229 final List<org.jrubyparser.ast.Node> children = node.childNodes(); | |
| 230 | |
| 231 final List<RubyNode> translatedChildren = new ArrayList<>(); | |
| 232 | |
| 233 for (int n = 0; n < children.size(); n++) { | |
| 234 final RubyNode translatedChild = (RubyNode) children.get(n).accept(this); | |
| 235 | |
| 236 if (!(translatedChild instanceof DeadNode)) { | |
| 237 translatedChildren.add(translatedChild); | |
| 238 } | |
| 239 } | |
| 240 | |
| 241 if (translatedChildren.size() == 1) { | |
| 242 return translatedChildren.get(0); | |
| 243 } else { | |
| 244 return new SequenceNode(context, translate(node.getPosition()), translatedChildren.toArray(new RubyNode[translatedChildren.size()])); | |
| 245 } | |
| 246 } | |
| 247 | |
| 248 @Override | |
| 249 public Object visitBlockPassNode(org.jrubyparser.ast.BlockPassNode node) { | |
| 250 return unimplemented(node); | |
| 251 } | |
| 252 | |
| 253 @Override | |
| 254 public Object visitBreakNode(org.jrubyparser.ast.BreakNode node) { | |
| 255 final SourceSection sourceSection = translate(node.getPosition()); | |
| 256 | |
| 257 RubyNode resultNode; | |
| 258 | |
| 259 if (node.getValueNode() == null) { | |
| 260 resultNode = new NilNode(context, sourceSection); | |
| 261 } else { | |
| 262 resultNode = (RubyNode) node.getValueNode().accept(this); | |
| 263 } | |
| 264 | |
| 265 return new BreakNode(context, sourceSection, resultNode); | |
| 266 } | |
| 267 | |
| 268 @Override | |
| 269 public Object visitCallNode(org.jrubyparser.ast.CallNode node) { | |
| 270 return visitCallNodeExtraArgument(node, null); | |
| 271 } | |
| 272 | |
| 273 /** | |
| 274 * See translateDummyAssignment to understand what this is for. | |
| 275 */ | |
| 276 public RubyNode visitCallNodeExtraArgument(org.jrubyparser.ast.CallNode node, RubyNode extraArgument) { | |
| 277 final SourceSection sourceSection = translate(node.getPosition()); | |
| 278 | |
| 279 final RubyNode receiverTranslated = (RubyNode) node.getReceiver().accept(this); | |
| 280 | |
| 281 org.jrubyparser.ast.Node args = node.getArgs(); | |
| 282 org.jrubyparser.ast.Node block = node.getIter(); | |
| 283 | |
| 284 if (block == null && args instanceof org.jrubyparser.ast.IterNode) { | |
| 285 final org.jrubyparser.ast.Node temp = args; | |
| 286 args = block; | |
| 287 block = temp; | |
| 288 } | |
| 289 | |
| 290 final ArgumentsAndBlockTranslation argumentsAndBlock = translateArgumentsAndBlock(sourceSection, block, args, extraArgument); | |
| 291 | |
|
13569
1894412de0ed
Ruby: major upgrade in debugging support, mainly for navigation: step, next (passing over calls), return (from enclosing function), etc. Also a few bug fixes.
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13514
diff
changeset
|
292 RubyNode translated = new CallNode(context, sourceSection, node.getName(), receiverTranslated, argumentsAndBlock.getBlock(), argumentsAndBlock.isSplatted(), argumentsAndBlock.getArguments()); |
|
1894412de0ed
Ruby: major upgrade in debugging support, mainly for navigation: step, next (passing over calls), return (from enclosing function), etc. Also a few bug fixes.
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13514
diff
changeset
|
293 |
|
13735
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
294 return instrumenter.instrumentAsCall(translated, node.getName()); |
| 13514 | 295 } |
| 296 | |
| 297 protected class ArgumentsAndBlockTranslation { | |
| 298 | |
| 299 private final RubyNode block; | |
| 300 private final RubyNode[] arguments; | |
| 301 private final boolean isSplatted; | |
| 302 | |
| 303 public ArgumentsAndBlockTranslation(RubyNode block, RubyNode[] arguments, boolean isSplatted) { | |
| 304 super(); | |
| 305 this.block = block; | |
| 306 this.arguments = arguments; | |
| 307 this.isSplatted = isSplatted; | |
| 308 } | |
| 309 | |
| 310 public RubyNode getBlock() { | |
| 311 return block; | |
| 312 } | |
| 313 | |
| 314 public RubyNode[] getArguments() { | |
| 315 return arguments; | |
| 316 } | |
| 317 | |
| 318 public boolean isSplatted() { | |
| 319 return isSplatted; | |
| 320 } | |
| 321 | |
| 322 } | |
| 323 | |
| 324 protected ArgumentsAndBlockTranslation translateArgumentsAndBlock(SourceSection sourceSection, org.jrubyparser.ast.Node iterNode, org.jrubyparser.ast.Node argsNode, RubyNode extraArgument) { | |
| 325 assert !(argsNode instanceof org.jrubyparser.ast.IterNode); | |
| 326 | |
| 327 final List<org.jrubyparser.ast.Node> arguments = new ArrayList<>(); | |
| 328 org.jrubyparser.ast.Node blockPassNode = null; | |
| 329 | |
| 330 boolean isSplatted = false; | |
| 331 | |
| 332 if (argsNode instanceof org.jrubyparser.ast.ListNode) { | |
| 333 arguments.addAll(((org.jrubyparser.ast.ListNode) argsNode).childNodes()); | |
| 334 } else if (argsNode instanceof org.jrubyparser.ast.BlockPassNode) { | |
| 335 final org.jrubyparser.ast.BlockPassNode blockPass = (org.jrubyparser.ast.BlockPassNode) argsNode; | |
| 336 | |
| 337 final org.jrubyparser.ast.Node blockPassArgs = blockPass.getArgs(); | |
| 338 | |
| 339 if (blockPassArgs instanceof org.jrubyparser.ast.ListNode) { | |
| 340 arguments.addAll(((org.jrubyparser.ast.ListNode) blockPassArgs).childNodes()); | |
| 341 } else if (blockPassArgs instanceof org.jrubyparser.ast.ArgsCatNode) { | |
| 342 arguments.add(blockPassArgs); | |
| 343 } else if (blockPassArgs != null) { | |
| 344 throw new UnsupportedOperationException("Don't know how to block pass " + blockPassArgs); | |
| 345 } | |
| 346 | |
| 347 blockPassNode = blockPass.getBody(); | |
| 348 } else if (argsNode instanceof org.jrubyparser.ast.SplatNode) { | |
| 349 isSplatted = true; | |
| 350 arguments.add(argsNode); | |
| 351 } else if (argsNode instanceof org.jrubyparser.ast.ArgsCatNode) { | |
| 352 isSplatted = true; | |
| 353 arguments.add(argsNode); | |
| 354 } else if (argsNode != null) { | |
| 355 isSplatted = true; | |
| 356 arguments.add(argsNode); | |
| 357 } | |
| 358 | |
| 359 RubyNode blockTranslated; | |
| 360 | |
| 361 if (blockPassNode != null && iterNode != null) { | |
| 362 throw new UnsupportedOperationException("Don't know how to pass both an block and a block-pass argument"); | |
| 363 } else if (iterNode != null) { | |
| 364 blockTranslated = (BlockDefinitionNode) iterNode.accept(this); | |
| 365 } else if (blockPassNode != null) { | |
| 366 blockTranslated = ProcCastNodeFactory.create(context, sourceSection, (RubyNode) blockPassNode.accept(this)); | |
| 367 } else { | |
| 368 blockTranslated = null; | |
| 369 } | |
| 370 | |
| 371 final List<RubyNode> argumentsTranslated = new ArrayList<>(); | |
| 372 | |
| 373 for (org.jrubyparser.ast.Node argument : arguments) { | |
| 374 argumentsTranslated.add((RubyNode) argument.accept(this)); | |
| 375 } | |
| 376 | |
| 377 if (extraArgument != null) { | |
| 378 argumentsTranslated.add(extraArgument); | |
| 379 } | |
| 380 | |
| 381 final RubyNode[] argumentsTranslatedArray = argumentsTranslated.toArray(new RubyNode[argumentsTranslated.size()]); | |
| 382 | |
| 383 return new ArgumentsAndBlockTranslation(blockTranslated, argumentsTranslatedArray, isSplatted); | |
| 384 } | |
| 385 | |
| 386 @Override | |
| 387 public Object visitCaseNode(org.jrubyparser.ast.CaseNode node) { | |
| 388 final SourceSection sourceSection = translate(node.getPosition()); | |
| 389 | |
| 390 RubyNode elseNode; | |
| 391 | |
| 392 if (node.getElse() != null) { | |
| 393 elseNode = (RubyNode) node.getElse().accept(this); | |
| 394 } else { | |
| 395 elseNode = new NilNode(context, sourceSection); | |
| 396 } | |
| 397 | |
| 398 /* | |
| 399 * There are two sorts of case - one compares a list of expressions against a value, the | |
| 400 * other just checks a list of expressions for truth. | |
| 401 */ | |
| 402 | |
| 403 if (node.getCase() != null) { | |
| 404 // Evaluate the case expression and store it in a local | |
| 405 | |
| 406 final String tempName = environment.allocateLocalTemp(); | |
| 407 | |
| 408 final RubyNode readTemp = environment.findLocalVarNode(tempName, sourceSection); | |
| 409 | |
| 410 final RubyNode assignTemp = ((ReadNode) readTemp).makeWriteNode((RubyNode) node.getCase().accept(this)); | |
| 411 | |
| 412 /* | |
| 413 * Build an if expression from the whens and else. Work backwards because the first if | |
| 414 * contains all the others in its else clause. | |
| 415 */ | |
| 416 | |
| 417 for (int n = node.getCases().size() - 1; n >= 0; n--) { | |
| 418 final org.jrubyparser.ast.WhenNode when = (org.jrubyparser.ast.WhenNode) node.getCases().get(n); | |
| 419 | |
| 420 // Make a condition from the one or more expressions combined in an or expression | |
| 421 | |
| 422 final List<org.jrubyparser.ast.Node> expressions; | |
| 423 | |
| 424 if (when.getExpression() instanceof org.jrubyparser.ast.ListNode) { | |
| 425 expressions = ((org.jrubyparser.ast.ListNode) when.getExpression()).childNodes(); | |
| 426 } else { | |
| 427 expressions = Arrays.asList(when.getExpression()); | |
| 428 } | |
| 429 | |
| 430 final List<RubyNode> comparisons = new ArrayList<>(); | |
| 431 | |
| 432 for (org.jrubyparser.ast.Node expressionNode : expressions) { | |
| 433 final RubyNode rubyExpression = (RubyNode) expressionNode.accept(this); | |
| 434 | |
| 435 final CallNode comparison = new CallNode(context, sourceSection, "===", rubyExpression, null, false, new RubyNode[]{environment.findLocalVarNode(tempName, sourceSection)}); | |
| 436 | |
| 437 comparisons.add(comparison); | |
| 438 } | |
| 439 | |
| 440 RubyNode conditionNode = comparisons.get(comparisons.size() - 1); | |
| 441 | |
| 442 // As with the if nodes, we work backwards to make it left associative | |
| 443 | |
| 444 for (int i = comparisons.size() - 2; i >= 0; i--) { | |
| 445 conditionNode = OrNodeFactory.create(context, sourceSection, comparisons.get(i), conditionNode); | |
| 446 } | |
| 447 | |
| 448 // Create the if node | |
| 449 | |
| 450 final BooleanCastNode conditionCastNode = BooleanCastNodeFactory.create(context, sourceSection, conditionNode); | |
| 451 | |
| 452 RubyNode thenNode; | |
| 453 | |
| 454 if (when.getBody() == null) { | |
| 455 thenNode = new NilNode(context, sourceSection); | |
| 456 } else { | |
| 457 thenNode = (RubyNode) when.getBody().accept(this); | |
| 458 } | |
| 459 | |
| 460 final IfNode ifNode = new IfNode(context, sourceSection, conditionCastNode, thenNode, elseNode); | |
| 461 | |
| 462 // This if becomes the else for the next if | |
| 463 | |
| 464 elseNode = ifNode; | |
| 465 } | |
| 466 | |
| 467 final RubyNode ifNode = elseNode; | |
| 468 | |
| 469 // A top-level block assigns the temp then runs the if | |
| 470 | |
| 471 return new SequenceNode(context, sourceSection, assignTemp, ifNode); | |
| 472 } else { | |
| 473 for (int n = node.getCases().size() - 1; n >= 0; n--) { | |
| 474 final org.jrubyparser.ast.WhenNode when = (org.jrubyparser.ast.WhenNode) node.getCases().get(n); | |
| 475 | |
| 476 // Make a condition from the one or more expressions combined in an or expression | |
| 477 | |
| 478 final List<org.jrubyparser.ast.Node> expressions; | |
| 479 | |
| 480 if (when.getExpression() instanceof org.jrubyparser.ast.ListNode) { | |
| 481 expressions = ((org.jrubyparser.ast.ListNode) when.getExpression()).childNodes(); | |
| 482 } else { | |
| 483 expressions = Arrays.asList(when.getExpression()); | |
| 484 } | |
| 485 | |
| 486 final List<RubyNode> tests = new ArrayList<>(); | |
| 487 | |
| 488 for (org.jrubyparser.ast.Node expressionNode : expressions) { | |
| 489 final RubyNode rubyExpression = (RubyNode) expressionNode.accept(this); | |
| 490 tests.add(rubyExpression); | |
| 491 } | |
| 492 | |
| 493 RubyNode conditionNode = tests.get(tests.size() - 1); | |
| 494 | |
| 495 // As with the if nodes, we work backwards to make it left associative | |
| 496 | |
| 497 for (int i = tests.size() - 2; i >= 0; i--) { | |
| 498 conditionNode = OrNodeFactory.create(context, sourceSection, tests.get(i), conditionNode); | |
| 499 } | |
| 500 | |
| 501 // Create the if node | |
| 502 | |
| 503 final BooleanCastNode conditionCastNode = BooleanCastNodeFactory.create(context, sourceSection, conditionNode); | |
| 504 | |
| 505 final RubyNode thenNode = (RubyNode) when.getBody().accept(this); | |
| 506 | |
| 507 final IfNode ifNode = new IfNode(context, sourceSection, conditionCastNode, thenNode, elseNode); | |
| 508 | |
| 509 // This if becomes the else for the next if | |
| 510 | |
| 511 elseNode = ifNode; | |
| 512 } | |
| 513 | |
| 514 return elseNode; | |
| 515 } | |
| 516 } | |
| 517 | |
| 518 @Override | |
| 519 public Object visitClassNode(org.jrubyparser.ast.ClassNode node) { | |
| 520 final SourceSection sourceSection = translate(node.getPosition()); | |
| 521 | |
| 522 final String name = node.getCPath().getName(); | |
| 523 | |
| 524 final TranslatorEnvironment newEnvironment = new TranslatorEnvironment(context, environment, environment.getParser(), environment.getParser().allocateReturnID(), true, true, | |
| 525 new UniqueMethodIdentifier()); | |
| 526 final ModuleTranslator classTranslator = new ModuleTranslator(context, this, newEnvironment, source); | |
| 527 | |
| 528 final MethodDefinitionNode definitionMethod = classTranslator.compileClassNode(node.getPosition(), node.getCPath().getName(), node.getBody()); | |
| 529 | |
| 530 /* | |
| 531 * See my note in visitDefnNode about where the class gets defined - the same applies here. | |
| 532 */ | |
| 533 | |
| 534 RubyNode superClass; | |
| 535 | |
| 536 if (node.getSuper() != null) { | |
| 537 superClass = (RubyNode) node.getSuper().accept(this); | |
| 538 } else { | |
| 539 superClass = new ObjectLiteralNode(context, sourceSection, context.getCoreLibrary().getObjectClass()); | |
| 540 } | |
| 541 | |
| 542 final DefineOrGetClassNode defineOrGetClass = new DefineOrGetClassNode(context, sourceSection, name, getModuleToDefineModulesIn(sourceSection), superClass); | |
| 543 | |
| 544 return new OpenModuleNode(context, sourceSection, defineOrGetClass, definitionMethod); | |
| 545 } | |
| 546 | |
| 547 protected RubyNode getModuleToDefineModulesIn(SourceSection sourceSection) { | |
| 548 return new ClassNode(context, sourceSection, new SelfNode(context, sourceSection)); | |
| 549 } | |
| 550 | |
| 551 @Override | |
| 552 public Object visitClassVarAsgnNode(org.jrubyparser.ast.ClassVarAsgnNode node) { | |
| 553 final SourceSection sourceSection = translate(node.getPosition()); | |
| 554 | |
| 555 final RubyNode receiver = new ClassNode(context, sourceSection, new SelfNode(context, sourceSection)); | |
| 556 | |
| 557 final RubyNode rhs = (RubyNode) node.getValue().accept(this); | |
| 558 | |
| 559 return new WriteClassVariableNode(context, sourceSection, node.getName(), receiver, rhs); | |
| 560 } | |
| 561 | |
| 562 @Override | |
| 563 public Object visitClassVarDeclNode(org.jrubyparser.ast.ClassVarDeclNode node) { | |
| 564 return unimplemented(node); | |
| 565 } | |
| 566 | |
| 567 @Override | |
| 568 public Object visitClassVarNode(org.jrubyparser.ast.ClassVarNode node) { | |
| 569 final SourceSection sourceSection = translate(node.getPosition()); | |
| 570 return new ReadClassVariableNode(context, sourceSection, node.getName(), new SelfNode(context, sourceSection)); | |
| 571 } | |
| 572 | |
| 573 @Override | |
| 574 public Object visitColon2Node(org.jrubyparser.ast.Colon2Node node) { | |
| 575 final RubyNode lhs = (RubyNode) node.getLeftNode().accept(this); | |
| 576 | |
| 577 return new UninitializedReadConstantNode(context, translate(node.getPosition()), node.getName(), lhs); | |
| 578 } | |
| 579 | |
| 580 @Override | |
| 581 public Object visitColon3Node(org.jrubyparser.ast.Colon3Node node) { | |
| 582 // Colon3 means the root namespace, as in ::Foo | |
| 583 | |
| 584 final SourceSection sourceSection = translate(node.getPosition()); | |
| 585 | |
| 586 final ObjectLiteralNode root = new ObjectLiteralNode(context, sourceSection, context.getCoreLibrary().getMainObject()); | |
| 587 | |
| 588 return new UninitializedReadConstantNode(context, sourceSection, node.getName(), root); | |
| 589 } | |
| 590 | |
| 591 @Override | |
| 592 public Object visitConstDeclNode(org.jrubyparser.ast.ConstDeclNode node) { | |
| 593 final SourceSection sourceSection = translate(node.getPosition()); | |
| 594 | |
| 595 final ClassNode classNode = new ClassNode(context, sourceSection, new SelfNode(context, sourceSection)); | |
| 596 | |
| 597 return new WriteConstantNode(context, sourceSection, node.getName(), classNode, (RubyNode) node.getValue().accept(this)); | |
| 598 } | |
| 599 | |
| 600 @Override | |
| 601 public Object visitConstNode(org.jrubyparser.ast.ConstNode node) { | |
| 602 final SourceSection sourceSection = translate(node.getPosition()); | |
| 603 | |
| 604 return new UninitializedReadConstantNode(context, sourceSection, node.getName(), new SelfNode(context, sourceSection)); | |
| 605 } | |
| 606 | |
| 607 @Override | |
| 608 public Object visitDAsgnNode(org.jrubyparser.ast.DAsgnNode node) { | |
| 609 return new org.jrubyparser.ast.LocalAsgnNode(node.getPosition(), node.getName(), node.getDepth(), node.getValue()).accept(this); | |
| 610 } | |
| 611 | |
| 612 @Override | |
| 613 public Object visitDRegxNode(org.jrubyparser.ast.DRegexpNode node) { | |
| 614 SourceSection sourceSection = translate(node.getPosition()); | |
| 615 | |
| 616 final RubyNode stringNode = translateInterpolatedString(sourceSection, node.childNodes()); | |
| 617 | |
| 618 return StringToRegexpNodeFactory.create(context, sourceSection, stringNode); | |
| 619 } | |
| 620 | |
| 621 @Override | |
| 622 public Object visitDStrNode(org.jrubyparser.ast.DStrNode node) { | |
| 623 return translateInterpolatedString(translate(node.getPosition()), node.childNodes()); | |
| 624 } | |
| 625 | |
| 626 @Override | |
| 627 public Object visitDSymbolNode(org.jrubyparser.ast.DSymbolNode node) { | |
| 628 SourceSection sourceSection = translate(node.getPosition()); | |
| 629 | |
| 630 final RubyNode stringNode = translateInterpolatedString(sourceSection, node.childNodes()); | |
| 631 | |
| 632 return StringToSymbolNodeFactory.create(context, sourceSection, stringNode); | |
| 633 } | |
| 634 | |
| 635 private RubyNode translateInterpolatedString(SourceSection sourceSection, List<org.jrubyparser.ast.Node> childNodes) { | |
| 636 final List<RubyNode> children = new ArrayList<>(); | |
| 637 | |
| 638 for (org.jrubyparser.ast.Node child : childNodes) { | |
| 639 children.add((RubyNode) child.accept(this)); | |
| 640 } | |
| 641 | |
| 642 return new InterpolatedStringNode(context, sourceSection, children.toArray(new RubyNode[children.size()])); | |
| 643 } | |
| 644 | |
| 645 @Override | |
| 646 public Object visitDVarNode(org.jrubyparser.ast.DVarNode node) { | |
| 647 RubyNode readNode = environment.findLocalVarNode(node.getName(), translate(node.getPosition())); | |
| 648 | |
| 649 if (readNode == null) { | |
| 650 context.implementationMessage("can't find variable %s at %s, using noop", node.getName(), node.getPosition()); | |
| 651 readNode = new NilNode(context, translate(node.getPosition())); | |
| 652 } | |
| 653 | |
| 654 return readNode; | |
| 655 } | |
| 656 | |
| 657 @Override | |
| 658 public Object visitDXStrNode(org.jrubyparser.ast.DXStrNode node) { | |
| 659 SourceSection sourceSection = translate(node.getPosition()); | |
| 660 | |
| 661 final RubyNode string = translateInterpolatedString(sourceSection, node.childNodes()); | |
| 662 | |
| 663 return new SystemNode(context, sourceSection, string); | |
| 664 } | |
| 665 | |
| 666 @Override | |
| 667 public Object visitDefinedNode(org.jrubyparser.ast.DefinedNode node) { | |
| 668 final SourceSection sourceSection = translate(node.getPosition()); | |
| 669 | |
| 670 org.jrubyparser.ast.Node expressionNode = node.getExpression(); | |
| 671 | |
| 672 while (expressionNode instanceof org.jrubyparser.ast.NewlineNode) { | |
| 673 expressionNode = ((org.jrubyparser.ast.NewlineNode) expressionNode).getNextNode(); | |
| 674 } | |
| 675 | |
| 676 final String name = nodeDefinedNames.get(expressionNode.getClass()); | |
| 677 | |
| 678 if (name != null) { | |
| 679 final StringLiteralNode literal = new StringLiteralNode(context, sourceSection, name); | |
| 680 return literal; | |
| 681 } | |
| 682 | |
| 683 return new DefinedNode(context, sourceSection, (RubyNode) node.getExpression().accept(this)); | |
| 684 } | |
| 685 | |
| 686 @Override | |
| 687 public Object visitDefnNode(org.jrubyparser.ast.DefnNode node) { | |
| 688 final SourceSection sourceSection = translate(node.getPosition()); | |
| 689 final ClassNode classNode = new ClassNode(context, sourceSection, new SelfNode(context, sourceSection)); | |
| 690 return translateMethodDefinition(sourceSection, classNode, node.getName(), node.getArgs(), node.getBody()); | |
| 691 } | |
| 692 | |
| 693 @Override | |
| 694 public Object visitDefsNode(org.jrubyparser.ast.DefsNode node) { | |
| 695 final SourceSection sourceSection = translate(node.getPosition()); | |
| 696 | |
| 697 final RubyNode objectNode = (RubyNode) node.getReceiver().accept(this); | |
| 698 | |
| 699 final SingletonClassNode singletonClassNode = new SingletonClassNode(context, sourceSection, objectNode); | |
| 700 | |
| 701 return translateMethodDefinition(sourceSection, singletonClassNode, node.getName(), node.getArgs(), node.getBody()); | |
| 702 } | |
| 703 | |
| 704 private RubyNode translateMethodDefinition(SourceSection sourceSection, RubyNode classNode, String methodName, org.jrubyparser.ast.ArgsNode argsNode, org.jrubyparser.ast.Node bodyNode) { | |
| 705 final TranslatorEnvironment newEnvironment = new TranslatorEnvironment(context, environment, environment.getParser(), environment.getParser().allocateReturnID(), true, true, | |
| 706 new UniqueMethodIdentifier()); | |
| 707 | |
| 708 // ownScopeForAssignments is the same for the defined method as the current one. | |
| 709 | |
| 710 final MethodTranslator methodCompiler = new MethodTranslator(context, this, newEnvironment, false, source); | |
| 711 | |
| 712 final MethodDefinitionNode functionExprNode = methodCompiler.compileFunctionNode(sourceSection, methodName, argsNode, bodyNode); | |
| 713 | |
| 714 /* | |
| 715 * In the top-level, methods are defined in the class of the main object. This is | |
| 716 * counter-intuitive - I would have expected them to be defined in the singleton class. | |
| 717 * Apparently this is a design decision to make top-level methods sort of global. | |
| 718 * | |
| 719 * http://stackoverflow.com/questions/1761148/where-are-methods-defined-at-the-ruby-top-level | |
| 720 */ | |
| 721 | |
| 722 return new AddMethodNode(context, sourceSection, classNode, functionExprNode); | |
| 723 } | |
| 724 | |
| 725 @Override | |
| 726 public Object visitDotNode(org.jrubyparser.ast.DotNode node) { | |
| 727 final RubyNode begin = (RubyNode) node.getBegin().accept(this); | |
| 728 final RubyNode end = (RubyNode) node.getEnd().accept(this); | |
| 729 SourceSection sourceSection = translate(node.getPosition()); | |
| 730 | |
| 731 if (begin instanceof FixnumLiteralNode && end instanceof FixnumLiteralNode) { | |
| 732 final int beginValue = ((FixnumLiteralNode) begin).getValue(); | |
| 733 final int endValue = ((FixnumLiteralNode) end).getValue(); | |
| 734 | |
| 735 return new ObjectLiteralNode(context, sourceSection, new FixnumRange(context.getCoreLibrary().getRangeClass(), beginValue, endValue, node.isExclusive())); | |
| 736 } | |
| 737 // See RangeNode for why there is a node specifically for creating this one type | |
| 738 return RangeLiteralNodeFactory.create(context, sourceSection, node.isExclusive(), begin, end); | |
| 739 } | |
| 740 | |
| 741 @Override | |
| 742 public Object visitEncodingNode(org.jrubyparser.ast.EncodingNode node) { | |
| 743 return unimplemented(node); | |
| 744 } | |
| 745 | |
| 746 @Override | |
| 747 public Object visitEnsureNode(org.jrubyparser.ast.EnsureNode node) { | |
| 748 final RubyNode tryPart = (RubyNode) node.getBody().accept(this); | |
| 749 final RubyNode ensurePart = (RubyNode) node.getEnsure().accept(this); | |
| 750 return new EnsureNode(context, translate(node.getPosition()), tryPart, ensurePart); | |
| 751 } | |
| 752 | |
| 753 @Override | |
| 754 public Object visitEvStrNode(org.jrubyparser.ast.EvStrNode node) { | |
| 755 return node.getBody().accept(this); | |
| 756 } | |
| 757 | |
| 758 @Override | |
| 759 public Object visitFCallNode(org.jrubyparser.ast.FCallNode node) { | |
| 760 final org.jrubyparser.ast.Node receiver = new org.jrubyparser.ast.SelfNode(node.getPosition()); | |
| 761 final org.jrubyparser.ast.Node callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), receiver, node.getName(), node.getArgs(), node.getIter()); | |
| 762 | |
| 763 return callNode.accept(this); | |
| 764 } | |
| 765 | |
| 766 @Override | |
| 767 public Object visitFalseNode(org.jrubyparser.ast.FalseNode node) { | |
| 768 return new BooleanLiteralNode(context, translate(node.getPosition()), false); | |
| 769 } | |
| 770 | |
| 771 @Override | |
| 772 public Object visitFixnumNode(org.jrubyparser.ast.FixnumNode node) { | |
| 773 final long value = node.getValue(); | |
| 774 | |
| 775 if (value >= RubyFixnum.MIN_VALUE && value <= RubyFixnum.MAX_VALUE) { | |
| 776 return new FixnumLiteralNode(context, translate(node.getPosition()), (int) value); | |
| 777 } | |
| 778 return new BignumLiteralNode(context, translate(node.getPosition()), BigInteger.valueOf(value)); | |
| 779 } | |
| 780 | |
| 781 @Override | |
| 782 public Object visitFlipNode(org.jrubyparser.ast.FlipNode node) { | |
| 783 final SourceSection sourceSection = translate(node.getPosition()); | |
| 784 | |
| 785 final RubyNode begin = (RubyNode) node.getBegin().accept(this); | |
| 786 final RubyNode end = (RubyNode) node.getEnd().accept(this); | |
| 787 | |
| 788 final BooleanCastNode beginCast = BooleanCastNodeFactory.create(context, sourceSection, begin); | |
| 789 final BooleanCastNode endCast = BooleanCastNodeFactory.create(context, sourceSection, end); | |
| 790 final FlipFlopStateNode stateNode = createFlipFlopState(sourceSection, 0); | |
| 791 | |
| 792 return new FlipFlopNode(context, sourceSection, beginCast, endCast, stateNode, node.isExclusive()); | |
| 793 } | |
| 794 | |
| 795 protected FlipFlopStateNode createFlipFlopState(SourceSection sourceSection, int depth) { | |
| 796 final FrameSlot frameSlot = environment.declareVar(environment.allocateLocalTemp()); | |
| 797 environment.getFlipFlopStates().add(frameSlot); | |
| 798 | |
| 799 if (depth == 0) { | |
| 800 return new LocalFlipFlopStateNode(sourceSection, frameSlot); | |
| 801 } else { | |
| 802 return new LevelFlipFlopStateNode(sourceSection, depth, frameSlot); | |
| 803 } | |
| 804 } | |
| 805 | |
| 806 @Override | |
| 807 public Object visitFloatNode(org.jrubyparser.ast.FloatNode node) { | |
| 808 return new FloatLiteralNode(context, translate(node.getPosition()), node.getValue()); | |
| 809 } | |
| 810 | |
| 811 @Override | |
| 812 public Object visitForNode(org.jrubyparser.ast.ForNode node) { | |
| 813 /** | |
| 814 * A Ruby for-loop, such as: | |
| 815 * | |
| 816 * <pre> | |
| 817 * for x in y | |
| 818 * z = x | |
| 819 * puts z | |
| 820 * end | |
| 821 * </pre> | |
| 822 * | |
| 823 * naively desugars to: | |
| 824 * | |
| 825 * <pre> | |
| 826 * y.each do |x| | |
| 827 * z = x | |
| 828 * puts z | |
| 829 * end | |
| 830 * </pre> | |
| 831 * | |
| 832 * The main difference is that z is always going to be local to the scope outside the block, | |
| 833 * so it's a bit more like: | |
| 834 * | |
| 835 * <pre> | |
| 836 * z = nil unless z is already defined | |
| 837 * y.each do |x| | |
| 838 * z = x | |
| 839 * puts x | |
| 840 * end | |
| 841 * </pre> | |
| 842 * | |
| 843 * Which forces z to be defined in the correct scope. The parser already correctly calls z a | |
| 844 * local, but then that causes us a problem as if we're going to translate to a block we | |
| 845 * need a formal parameter - not a local variable. My solution to this is to add a | |
| 846 * temporary: | |
| 847 * | |
| 848 * <pre> | |
| 849 * z = nil unless z is already defined | |
| 850 * y.each do |temp| | |
| 851 * x = temp | |
| 852 * z = x | |
| 853 * puts x | |
| 854 * end | |
| 855 * </pre> | |
| 856 * | |
| 857 * We also need that temp because the expression assigned in the for could be index | |
| 858 * assignment, multiple assignment, or whatever: | |
| 859 * | |
| 860 * <pre> | |
| 861 * for x[0] in y | |
| 862 * z = x[0] | |
| 863 * puts z | |
| 864 * end | |
| 865 * </pre> | |
| 866 * | |
| 867 * http://blog.grayproductions.net/articles/the_evils_of_the_for_loop | |
| 868 * http://stackoverflow.com/questions/3294509/for-vs-each-in-ruby | |
| 869 * | |
| 870 * The other complication is that normal locals should be defined in the enclosing scope, | |
| 871 * unlike a normal block. We do that by setting a flag on this translator object when we | |
| 872 * visit the new iter, translatingForStatement, which we recognise when visiting an iter | |
| 873 * node. | |
| 874 * | |
| 875 * Finally, note that JRuby's terminology is strange here. Normally 'iter' is a different | |
| 876 * term for a block. Here, JRuby calls the object being iterated over the 'iter'. | |
| 877 */ | |
| 878 | |
| 879 final String temp = environment.allocateLocalTemp(); | |
| 880 | |
| 881 final org.jrubyparser.ast.Node receiver = node.getIter(); | |
| 882 | |
| 883 /* | |
| 884 * The x in for x in ... is like the nodes in multiple assignment - it has a dummy RHS which | |
| 885 * we need to replace with our temp. Just like in multiple assignment this is really awkward | |
| 886 * with the JRuby AST. | |
| 887 */ | |
| 888 | |
| 889 final org.jrubyparser.ast.LocalVarNode readTemp = new org.jrubyparser.ast.LocalVarNode(node.getPosition(), 0, temp); | |
| 890 final org.jrubyparser.ast.Node forVar = node.getVar(); | |
| 891 final org.jrubyparser.ast.Node assignTemp = setRHS(forVar, readTemp); | |
| 892 | |
| 893 final org.jrubyparser.ast.BlockNode bodyWithTempAssign = new org.jrubyparser.ast.BlockNode(node.getPosition()); | |
| 894 bodyWithTempAssign.add(assignTemp); | |
| 895 bodyWithTempAssign.add(node.getBody()); | |
| 896 | |
| 897 final org.jrubyparser.ast.ArgumentNode blockVar = new org.jrubyparser.ast.ArgumentNode(node.getPosition(), temp); | |
| 898 final org.jrubyparser.ast.ListNode blockArgsPre = new org.jrubyparser.ast.ListNode(node.getPosition(), blockVar); | |
| 899 final org.jrubyparser.ast.ArgsNode blockArgs = new org.jrubyparser.ast.ArgsNode(node.getPosition(), blockArgsPre, null, null, null, null, null, null); | |
| 900 final org.jrubyparser.ast.IterNode block = new org.jrubyparser.ast.IterNode(node.getPosition(), blockArgs, node.getScope(), bodyWithTempAssign); | |
| 901 | |
| 902 final org.jrubyparser.ast.CallNode callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), receiver, "each", null, block); | |
| 903 | |
| 904 translatingForStatement = true; | |
| 905 final RubyNode translated = (RubyNode) callNode.accept(this); | |
| 906 translatingForStatement = false; | |
| 907 | |
| 908 return translated; | |
| 909 } | |
| 910 | |
| 911 private static org.jrubyparser.ast.Node setRHS(org.jrubyparser.ast.Node node, org.jrubyparser.ast.Node rhs) { | |
| 912 if (node instanceof org.jrubyparser.ast.LocalAsgnNode) { | |
| 913 final org.jrubyparser.ast.LocalAsgnNode localAsgnNode = (org.jrubyparser.ast.LocalAsgnNode) node; | |
| 914 return new org.jrubyparser.ast.LocalAsgnNode(node.getPosition(), localAsgnNode.getName(), 0, rhs); | |
| 915 } else if (node instanceof org.jrubyparser.ast.DAsgnNode) { | |
| 916 final org.jrubyparser.ast.DAsgnNode dAsgnNode = (org.jrubyparser.ast.DAsgnNode) node; | |
| 917 return new org.jrubyparser.ast.DAsgnNode(node.getPosition(), dAsgnNode.getName(), 0, rhs); | |
| 918 } else if (node instanceof org.jrubyparser.ast.MultipleAsgnNode) { | |
| 919 final org.jrubyparser.ast.MultipleAsgnNode multAsgnNode = (org.jrubyparser.ast.MultipleAsgnNode) node; | |
| 920 return new org.jrubyparser.ast.MultipleAsgnNode(node.getPosition(), multAsgnNode.getPre(), multAsgnNode.getRest(), multAsgnNode.getPost()); | |
| 921 } else if (node instanceof org.jrubyparser.ast.InstAsgnNode) { | |
| 922 final org.jrubyparser.ast.InstAsgnNode instAsgnNode = (org.jrubyparser.ast.InstAsgnNode) node; | |
| 923 return new org.jrubyparser.ast.InstAsgnNode(node.getPosition(), instAsgnNode.getName(), rhs); | |
| 924 } else if (node instanceof org.jrubyparser.ast.ClassVarAsgnNode) { | |
| 925 final org.jrubyparser.ast.ClassVarAsgnNode instAsgnNode = (org.jrubyparser.ast.ClassVarAsgnNode) node; | |
| 926 return new org.jrubyparser.ast.ClassVarAsgnNode(node.getPosition(), instAsgnNode.getName(), rhs); | |
| 927 } else if (node instanceof org.jrubyparser.ast.ConstDeclNode) { | |
| 928 final org.jrubyparser.ast.ConstDeclNode constDeclNode = (org.jrubyparser.ast.ConstDeclNode) node; | |
| 929 return new org.jrubyparser.ast.ConstDeclNode(node.getPosition(), constDeclNode.getName(), (org.jrubyparser.ast.INameNode) constDeclNode.getConstNode(), rhs); | |
| 930 } else { | |
| 931 throw new UnsupportedOperationException("Don't know how to set the RHS of a " + node.getClass().getName()); | |
| 932 } | |
| 933 } | |
| 934 | |
| 935 @Override | |
| 936 public Object visitGlobalAsgnNode(org.jrubyparser.ast.GlobalAsgnNode node) { | |
| 937 final SourceSection sourceSection = translate(node.getPosition()); | |
| 938 | |
| 939 final String name = "$" + node.getName(); | |
| 940 final RubyNode rhs = (RubyNode) node.getValue().accept(this); | |
| 941 | |
| 942 if (FRAME_LOCAL_GLOBAL_VARIABLES.contains(name)) { | |
| 943 context.implementationMessage("Assigning to frame local global variables not implemented at %s", node.getPosition()); | |
| 944 | |
| 945 return rhs; | |
| 946 } else { | |
| 947 final ObjectLiteralNode globalVariablesObjectNode = new ObjectLiteralNode(context, sourceSection, context.getCoreLibrary().getGlobalVariablesObject()); | |
| 948 | |
| 949 return new UninitializedWriteInstanceVariableNode(context, sourceSection, name, globalVariablesObjectNode, rhs); | |
| 950 } | |
| 951 } | |
| 952 | |
| 953 @Override | |
| 954 public Object visitGlobalVarNode(org.jrubyparser.ast.GlobalVarNode node) { | |
| 955 final String name = "$" + node.getName(); | |
| 956 final SourceSection sourceSection = translate(node.getPosition()); | |
| 957 | |
| 958 if (FRAME_LOCAL_GLOBAL_VARIABLES.contains(name)) { | |
| 959 // Assignment is implicit for many of these, so we need to declare when we use | |
| 960 | |
| 961 environment.declareVar(name); | |
| 962 | |
| 963 final RubyNode readNode = environment.findLocalVarNode(name, sourceSection); | |
| 964 | |
| 965 return readNode; | |
| 966 } else { | |
| 967 final ObjectLiteralNode globalVariablesObjectNode = new ObjectLiteralNode(context, sourceSection, context.getCoreLibrary().getGlobalVariablesObject()); | |
| 968 | |
| 969 return new UninitializedReadInstanceVariableNode(context, sourceSection, name, globalVariablesObjectNode); | |
| 970 } | |
| 971 } | |
| 972 | |
| 973 @Override | |
| 974 public Object visitHashNode(org.jrubyparser.ast.HashNode node) { | |
| 975 final SourceSection sourceSection = translate(node.getPosition()); | |
| 976 | |
| 977 final List<RubyNode> keys = new ArrayList<>(); | |
| 978 final List<RubyNode> values = new ArrayList<>(); | |
| 979 | |
| 980 final org.jrubyparser.ast.ListNode entries = node.getListNode(); | |
| 981 | |
| 982 assert entries.size() % 2 == 0; | |
| 983 | |
| 984 for (int n = 0; n < entries.size(); n += 2) { | |
| 985 if (entries.get(n) == null) { | |
| 986 final NilNode nilNode = new NilNode(context, sourceSection); | |
| 987 keys.add(nilNode); | |
| 988 } else { | |
| 989 keys.add((RubyNode) entries.get(n).accept(this)); | |
| 990 } | |
| 991 | |
| 992 if (entries.get(n + 1) == null) { | |
| 993 final NilNode nilNode = new NilNode(context, sourceSection); | |
| 994 values.add(nilNode); | |
| 995 } else { | |
| 996 values.add((RubyNode) entries.get(n + 1).accept(this)); | |
| 997 } | |
| 998 } | |
| 999 | |
| 1000 return new HashLiteralNode(translate(node.getPosition()), keys.toArray(new RubyNode[keys.size()]), values.toArray(new RubyNode[values.size()]), context); | |
| 1001 } | |
| 1002 | |
| 1003 @Override | |
| 1004 public Object visitIfNode(org.jrubyparser.ast.IfNode node) { | |
| 1005 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1006 | |
| 1007 org.jrubyparser.ast.Node thenBody = node.getThenBody(); | |
| 1008 | |
| 1009 if (thenBody == null) { | |
| 1010 thenBody = new org.jrubyparser.ast.NilNode(node.getPosition()); | |
| 1011 } | |
| 1012 | |
| 1013 org.jrubyparser.ast.Node elseBody = node.getElseBody(); | |
| 1014 | |
| 1015 if (elseBody == null) { | |
| 1016 elseBody = new org.jrubyparser.ast.NilNode(node.getPosition()); | |
| 1017 } | |
| 1018 | |
| 1019 RubyNode condition; | |
| 1020 | |
| 1021 if (node.getCondition() == null) { | |
| 1022 condition = new NilNode(context, sourceSection); | |
| 1023 } else { | |
| 1024 condition = (RubyNode) node.getCondition().accept(this); | |
| 1025 } | |
| 1026 | |
| 1027 final BooleanCastNode conditionCast = BooleanCastNodeFactory.create(context, sourceSection, condition); | |
| 1028 | |
| 1029 final RubyNode thenBodyTranslated = (RubyNode) thenBody.accept(this); | |
| 1030 final RubyNode elseBodyTranslated = (RubyNode) elseBody.accept(this); | |
| 1031 | |
| 1032 return new IfNode(context, sourceSection, conditionCast, thenBodyTranslated, elseBodyTranslated); | |
| 1033 } | |
| 1034 | |
| 1035 @Override | |
| 1036 public Object visitInstAsgnNode(org.jrubyparser.ast.InstAsgnNode node) { | |
| 1037 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1038 final String nameWithoutSigil = node.getName(); | |
| 1039 | |
| 1040 final RubyNode receiver = new SelfNode(context, sourceSection); | |
| 1041 | |
| 1042 RubyNode rhs; | |
| 1043 | |
| 1044 if (node.getValue() == null) { | |
| 1045 rhs = new DeadNode(context, sourceSection); | |
| 1046 } else { | |
| 1047 rhs = (RubyNode) node.getValue().accept(this); | |
| 1048 } | |
| 1049 | |
| 1050 return new UninitializedWriteInstanceVariableNode(context, sourceSection, nameWithoutSigil, receiver, rhs); | |
| 1051 } | |
| 1052 | |
| 1053 @Override | |
| 1054 public Object visitInstVarNode(org.jrubyparser.ast.InstVarNode node) { | |
| 1055 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1056 final String nameWithoutSigil = node.getName(); | |
| 1057 | |
| 1058 final RubyNode receiver = new SelfNode(context, sourceSection); | |
| 1059 | |
| 1060 return new UninitializedReadInstanceVariableNode(context, sourceSection, nameWithoutSigil, receiver); | |
| 1061 } | |
| 1062 | |
| 1063 @Override | |
| 1064 public Object visitIterNode(org.jrubyparser.ast.IterNode node) { | |
| 1065 /* | |
| 1066 * In a block we do NOT allocate a new return ID - returns will return from the method, not | |
| 1067 * the block (in the general case, see Proc and the difference between Proc and Lambda for | |
| 1068 * specifics). | |
| 1069 */ | |
| 1070 | |
| 1071 final boolean hasOwnScope = !translatingForStatement; | |
| 1072 | |
| 1073 // Unset this flag for any for any blocks within the for statement's body | |
| 1074 | |
| 1075 translatingForStatement = false; | |
| 1076 | |
| 1077 final TranslatorEnvironment newEnvironment = new TranslatorEnvironment(context, environment, environment.getParser(), environment.getReturnID(), hasOwnScope, false, | |
| 1078 new UniqueMethodIdentifier()); | |
| 1079 final MethodTranslator methodCompiler = new MethodTranslator(context, this, newEnvironment, true, source); | |
| 1080 | |
| 1081 org.jrubyparser.ast.ArgsNode argsNode; | |
| 1082 | |
| 1083 if (node.getVar() instanceof org.jrubyparser.ast.ArgsNode) { | |
| 1084 argsNode = (org.jrubyparser.ast.ArgsNode) node.getVar(); | |
| 1085 } else if (node.getVar() instanceof org.jrubyparser.ast.DAsgnNode) { | |
| 1086 final org.jrubyparser.ast.ArgumentNode arg = new org.jrubyparser.ast.ArgumentNode(node.getPosition(), ((org.jrubyparser.ast.DAsgnNode) node.getVar()).getName()); | |
| 1087 final org.jrubyparser.ast.ListNode preArgs = new org.jrubyparser.ast.ArrayNode(node.getPosition(), arg); | |
| 1088 argsNode = new org.jrubyparser.ast.ArgsNode(node.getPosition(), preArgs, null, null, null, null, null, null); | |
| 1089 } else if (node.getVar() == null) { | |
| 1090 argsNode = null; | |
| 1091 } else { | |
| 1092 throw new UnsupportedOperationException(); | |
| 1093 } | |
| 1094 | |
| 1095 return methodCompiler.compileFunctionNode(translate(node.getPosition()), "(block)", argsNode, node.getBody()); | |
| 1096 } | |
| 1097 | |
| 1098 @Override | |
| 1099 public Object visitLiteralNode(org.jrubyparser.ast.LiteralNode node) { | |
| 1100 return unimplemented(node); | |
| 1101 } | |
| 1102 | |
| 1103 @Override | |
| 1104 public Object visitLocalAsgnNode(org.jrubyparser.ast.LocalAsgnNode node) { | |
| 1105 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1106 | |
| 1107 if (environment.getNeverAssignInParentScope()) { | |
| 1108 environment.declareVar(node.getName()); | |
| 1109 } | |
| 1110 | |
| 1111 RubyNode lhs = environment.findLocalVarNode(node.getName(), sourceSection); | |
| 1112 | |
| 1113 if (lhs == null) { | |
| 1114 if (environment.hasOwnScopeForAssignments()) { | |
| 1115 environment.declareVar(node.getName()); | |
| 1116 } | |
| 1117 | |
| 1118 TranslatorEnvironment environmentToDeclareIn = environment; | |
| 1119 | |
| 1120 while (!environmentToDeclareIn.hasOwnScopeForAssignments()) { | |
| 1121 environmentToDeclareIn = environmentToDeclareIn.getParent(); | |
| 1122 } | |
| 1123 | |
| 1124 environmentToDeclareIn.declareVar(node.getName()); | |
| 1125 lhs = environment.findLocalVarNode(node.getName(), sourceSection); | |
| 1126 | |
| 1127 if (lhs == null) { | |
| 1128 throw new RuntimeException("shoudln't be here"); | |
| 1129 } | |
| 1130 } | |
| 1131 | |
| 1132 RubyNode rhs; | |
| 1133 | |
| 1134 if (node.getValue() == null) { | |
| 1135 rhs = new DeadNode(context, sourceSection); | |
| 1136 } else { | |
| 1137 rhs = (RubyNode) node.getValue().accept(this); | |
| 1138 } | |
| 1139 | |
| 1140 RubyNode translated = ((ReadNode) lhs).makeWriteNode(rhs); | |
| 1141 | |
|
13735
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
1142 final UniqueMethodIdentifier methodIdentifier = environment.findMethodForLocalVar(node.getName()); |
|
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
1143 |
|
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
1144 return instrumenter.instrumentAsLocalAssignment(translated, methodIdentifier, node.getName()); |
| 13514 | 1145 } |
| 1146 | |
| 1147 @Override | |
| 1148 public Object visitLocalVarNode(org.jrubyparser.ast.LocalVarNode node) { | |
| 1149 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1150 | |
| 1151 final String name = node.getName(); | |
| 1152 | |
| 1153 RubyNode readNode = environment.findLocalVarNode(name, sourceSection); | |
| 1154 | |
| 1155 if (readNode == null) { | |
| 1156 context.implementationMessage("Local variable found by parser but not by translator - " + name + " at " + node.getPosition()); | |
| 1157 readNode = environment.findLocalVarNode(environment.allocateLocalTemp(), sourceSection); | |
| 1158 } | |
| 1159 | |
| 1160 return readNode; | |
| 1161 } | |
| 1162 | |
| 1163 @Override | |
| 1164 public Object visitMatch2Node(org.jrubyparser.ast.Match2Node node) { | |
| 1165 final org.jrubyparser.ast.Node argsNode = buildArrayNode(node.getPosition(), node.getValue()); | |
| 1166 final org.jrubyparser.ast.Node callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), node.getReceiver(), "=~", argsNode, null); | |
| 1167 return callNode.accept(this); | |
| 1168 } | |
| 1169 | |
| 1170 @Override | |
| 1171 public Object visitMatch3Node(org.jrubyparser.ast.Match3Node node) { | |
| 1172 final org.jrubyparser.ast.Node argsNode = buildArrayNode(node.getPosition(), node.getValue()); | |
| 1173 final org.jrubyparser.ast.Node callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), node.getReceiver(), "=~", argsNode, null); | |
| 1174 return callNode.accept(this); | |
| 1175 } | |
| 1176 | |
| 1177 @Override | |
| 1178 public Object visitMatchNode(org.jrubyparser.ast.MatchNode node) { | |
| 1179 return unimplemented(node); | |
| 1180 } | |
| 1181 | |
| 1182 @Override | |
| 1183 public Object visitModuleNode(org.jrubyparser.ast.ModuleNode node) { | |
| 1184 // See visitClassNode | |
| 1185 | |
| 1186 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1187 | |
| 1188 final String name = node.getCPath().getName(); | |
| 1189 | |
| 1190 final TranslatorEnvironment newEnvironment = new TranslatorEnvironment(context, environment, environment.getParser(), environment.getParser().allocateReturnID(), true, true, | |
| 1191 new UniqueMethodIdentifier()); | |
| 1192 final ModuleTranslator classTranslator = new ModuleTranslator(context, this, newEnvironment, source); | |
| 1193 | |
| 1194 final MethodDefinitionNode definitionMethod = classTranslator.compileClassNode(node.getPosition(), node.getCPath().getName(), node.getBody()); | |
| 1195 | |
| 1196 final DefineOrGetModuleNode defineModuleNode = new DefineOrGetModuleNode(context, sourceSection, name, getModuleToDefineModulesIn(sourceSection)); | |
| 1197 | |
| 1198 return new OpenModuleNode(context, sourceSection, defineModuleNode, definitionMethod); | |
| 1199 } | |
| 1200 | |
| 1201 @Override | |
| 1202 public Object visitMultipleAsgnNode(org.jrubyparser.ast.MultipleAsgnNode node) { | |
| 1203 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1204 | |
| 1205 final org.jrubyparser.ast.ArrayNode preArray = (org.jrubyparser.ast.ArrayNode) node.getPre(); | |
| 1206 final org.jrubyparser.ast.Node rhs = node.getValue(); | |
| 1207 | |
| 1208 RubyNode rhsTranslated; | |
| 1209 | |
| 1210 if (rhs == null) { | |
| 1211 context.implementationMessage("warning: no RHS for multiple assignment - using noop"); | |
| 1212 rhsTranslated = new NilNode(context, sourceSection); | |
| 1213 } else { | |
| 1214 rhsTranslated = (RubyNode) rhs.accept(this); | |
| 1215 } | |
| 1216 | |
| 1217 /* | |
| 1218 * One very common case is to do | |
| 1219 * | |
| 1220 * a, b = c, d | |
| 1221 */ | |
| 1222 | |
| 1223 if (preArray != null && node.getPost() == null && node.getRest() == null && rhsTranslated instanceof UninitialisedArrayLiteralNode && | |
| 1224 ((UninitialisedArrayLiteralNode) rhsTranslated).getValues().length == preArray.size()) { | |
| 1225 /* | |
| 1226 * We can deal with this common case be rewriting as | |
| 1227 * | |
| 1228 * temp1 = c; temp2 = d; a = temp1; b = temp2 | |
| 1229 * | |
| 1230 * We can't just do | |
| 1231 * | |
| 1232 * a = c; b = d | |
| 1233 * | |
| 1234 * As we don't know if d depends on the original value of a. | |
| 1235 * | |
| 1236 * We also need to return an array [c, d], but we make that result elidable so it isn't | |
| 1237 * executed if it isn't actually demanded. | |
| 1238 */ | |
| 1239 | |
| 1240 final RubyNode[] rhsValues = ((UninitialisedArrayLiteralNode) rhsTranslated).getValues(); | |
| 1241 final int assignedValuesCount = preArray.size(); | |
| 1242 | |
| 1243 final RubyNode[] sequence = new RubyNode[assignedValuesCount * 2]; | |
| 1244 | |
| 1245 final RubyNode[] tempValues = new RubyNode[assignedValuesCount]; | |
| 1246 | |
| 1247 for (int n = 0; n < assignedValuesCount; n++) { | |
| 1248 final String tempName = environment.allocateLocalTemp(); | |
| 1249 final RubyNode readTemp = environment.findLocalVarNode(tempName, sourceSection); | |
| 1250 final RubyNode assignTemp = ((ReadNode) readTemp).makeWriteNode(rhsValues[n]); | |
| 1251 final RubyNode assignFinalValue = translateDummyAssignment(preArray.get(n), readTemp); | |
| 1252 | |
| 1253 sequence[n] = assignTemp; | |
| 1254 sequence[assignedValuesCount + n] = assignFinalValue; | |
| 1255 | |
| 1256 tempValues[n] = readTemp; | |
| 1257 } | |
| 1258 | |
| 1259 final RubyNode blockNode = new SequenceNode(context, sourceSection, sequence); | |
| 1260 | |
| 1261 final UninitialisedArrayLiteralNode arrayNode = new UninitialisedArrayLiteralNode(context, sourceSection, tempValues); | |
| 1262 | |
| 1263 final ElidableResultNode elidableResult = new ElidableResultNode(context, sourceSection, blockNode, arrayNode); | |
| 1264 | |
| 1265 return elidableResult; | |
| 1266 } else if (preArray != null) { | |
| 1267 /* | |
| 1268 * The other simple case is | |
| 1269 * | |
| 1270 * a, b, c = x | |
| 1271 * | |
| 1272 * If x is an array, then it's | |
| 1273 * | |
| 1274 * a[0] = x[0] etc | |
| 1275 * | |
| 1276 * If x isn't an array then it's | |
| 1277 * | |
| 1278 * a, b, c = [x, nil, nil] | |
| 1279 * | |
| 1280 * Which I believe is the same effect as | |
| 1281 * | |
| 1282 * a, b, c, = *x | |
| 1283 * | |
| 1284 * So we insert the splat cast node, even though it isn't there. | |
| 1285 */ | |
| 1286 | |
| 1287 /* | |
| 1288 * Create a temp for the array. | |
| 1289 */ | |
| 1290 | |
| 1291 final String tempName = environment.allocateLocalTemp(); | |
| 1292 | |
| 1293 /* | |
| 1294 * Create a sequence of instructions, with the first being the literal array assigned to | |
| 1295 * the temp. | |
| 1296 */ | |
| 1297 | |
| 1298 final List<RubyNode> sequence = new ArrayList<>(); | |
| 1299 | |
| 1300 final RubyNode splatCastNode = SplatCastNodeFactory.create(context, sourceSection, rhsTranslated); | |
| 1301 | |
| 1302 final RubyNode writeTemp = ((ReadNode) environment.findLocalVarNode(tempName, sourceSection)).makeWriteNode(splatCastNode); | |
| 1303 | |
| 1304 sequence.add(writeTemp); | |
| 1305 | |
| 1306 /* | |
| 1307 * Then index the temp array for each assignment on the LHS. | |
| 1308 */ | |
| 1309 | |
| 1310 for (int n = 0; n < preArray.size(); n++) { | |
| 1311 final ArrayIndexNode assignedValue = ArrayIndexNodeFactory.create(context, sourceSection, n, environment.findLocalVarNode(tempName, sourceSection)); | |
| 1312 | |
| 1313 sequence.add(translateDummyAssignment(preArray.get(n), assignedValue)); | |
| 1314 } | |
| 1315 | |
| 1316 if (node.getRest() != null) { | |
| 1317 final ArrayRestNode assignedValue = new ArrayRestNode(context, sourceSection, preArray.size(), environment.findLocalVarNode(tempName, sourceSection)); | |
| 1318 | |
| 1319 sequence.add(translateDummyAssignment(node.getRest(), assignedValue)); | |
| 1320 } | |
| 1321 | |
| 1322 return new SequenceNode(context, sourceSection, sequence.toArray(new RubyNode[sequence.size()])); | |
| 1323 } else if (node.getPre() == null && node.getPost() == null && node.getRest() instanceof org.jrubyparser.ast.StarNode) { | |
| 1324 return rhsTranslated; | |
| 1325 } else if (node.getPre() == null && node.getPost() == null && node.getRest() != null && rhs != null && !(rhs instanceof org.jrubyparser.ast.ArrayNode)) { | |
| 1326 /* | |
| 1327 * *a = b | |
| 1328 * | |
| 1329 * >= 1.8, this seems to be the same as: | |
| 1330 * | |
| 1331 * a = *b | |
| 1332 */ | |
| 1333 | |
| 1334 final RubyNode restTranslated = ((RubyNode) node.getRest().accept(this)).getNonProxyNode(); | |
| 1335 | |
| 1336 /* | |
| 1337 * Sometimes rest is a corrupt write with no RHS, like in other multiple assignments, | |
| 1338 * and sometimes it is already a read. | |
| 1339 */ | |
| 1340 | |
| 1341 ReadNode restRead; | |
| 1342 | |
| 1343 if (restTranslated instanceof ReadNode) { | |
| 1344 restRead = (ReadNode) restTranslated; | |
| 1345 } else if (restTranslated instanceof WriteNode) { | |
| 1346 restRead = (ReadNode) ((WriteNode) restTranslated).makeReadNode(); | |
| 1347 } else { | |
| 1348 throw new RuntimeException("Unknown form of multiple assignment " + node + " at " + node.getPosition()); | |
| 1349 } | |
| 1350 | |
| 1351 final SplatCastNode rhsSplatCast = SplatCastNodeFactory.create(context, sourceSection, rhsTranslated); | |
| 1352 | |
| 1353 return restRead.makeWriteNode(rhsSplatCast); | |
| 1354 } else if (node.getPre() == null && node.getPost() == null && node.getRest() != null && rhs != null && rhs instanceof org.jrubyparser.ast.ArrayNode) { | |
| 1355 /* | |
| 1356 * *a = [b, c] | |
| 1357 * | |
| 1358 * This seems to be the same as: | |
| 1359 * | |
| 1360 * a = [b, c] | |
| 1361 */ | |
| 1362 | |
| 1363 final RubyNode restTranslated = ((RubyNode) node.getRest().accept(this)).getNonProxyNode(); | |
| 1364 | |
| 1365 /* | |
| 1366 * Sometimes rest is a corrupt write with no RHS, like in other multiple assignments, | |
| 1367 * and sometimes it is already a read. | |
| 1368 */ | |
| 1369 | |
| 1370 ReadNode restRead; | |
| 1371 | |
| 1372 if (restTranslated instanceof ReadNode) { | |
| 1373 restRead = (ReadNode) restTranslated; | |
| 1374 } else if (restTranslated instanceof WriteNode) { | |
| 1375 restRead = (ReadNode) ((WriteNode) restTranslated).makeReadNode(); | |
| 1376 } else { | |
| 1377 throw new RuntimeException("Unknown form of multiple assignment " + node + " at " + node.getPosition()); | |
| 1378 } | |
| 1379 | |
| 1380 return restRead.makeWriteNode(rhsTranslated); | |
| 1381 } else { | |
| 1382 throw new RuntimeException("Unknown form of multiple assignment " + node + " at " + node.getPosition()); | |
| 1383 } | |
| 1384 } | |
| 1385 | |
| 1386 private RubyNode translateDummyAssignment(org.jrubyparser.ast.Node dummyAssignment, RubyNode rhs) { | |
| 1387 final SourceSection sourceSection = translate(dummyAssignment.getPosition()); | |
| 1388 | |
| 1389 /* | |
| 1390 * This is tricky. To represent the RHS of a multiple assignment they use corrupt assignment | |
| 1391 * values, in some cases with no value to be assigned, and in other cases with a dummy | |
| 1392 * value. We can't visit them normally, as they're corrupt. We can't just modify them to | |
| 1393 * have our RHS, as that's a node in our AST, not theirs. We can't use a dummy value in | |
| 1394 * their AST because I can't add new visitors to this interface. | |
| 1395 */ | |
| 1396 | |
| 1397 RubyNode translated; | |
| 1398 | |
| 1399 if (dummyAssignment instanceof org.jrubyparser.ast.LocalAsgnNode) { | |
| 1400 /* | |
| 1401 * They have a dummy NilImplicitNode as the RHS. Translate, convert to read, convert to | |
| 1402 * write which allows us to set the RHS. | |
| 1403 */ | |
| 1404 | |
| 1405 final WriteNode dummyTranslated = (WriteNode) ((RubyNode) dummyAssignment.accept(this)).getNonProxyNode(); | |
| 1406 translated = ((ReadNode) dummyTranslated.makeReadNode()).makeWriteNode(rhs); | |
| 1407 } else if (dummyAssignment instanceof org.jrubyparser.ast.InstAsgnNode) { | |
| 1408 /* | |
| 1409 * Same as before, just a different type of assignment. | |
| 1410 */ | |
| 1411 | |
| 1412 final WriteInstanceVariableNode dummyTranslated = (WriteInstanceVariableNode) dummyAssignment.accept(this); | |
| 1413 translated = dummyTranslated.makeReadNode().makeWriteNode(rhs); | |
| 1414 } else if (dummyAssignment instanceof org.jrubyparser.ast.AttrAssignNode) { | |
| 1415 /* | |
| 1416 * They've given us an AttrAssignNode with the final argument, the assigned value, | |
| 1417 * missing. If we translate that we'll get foo.[]=(index), so missing the value. To | |
| 1418 * solve we have a special version of the visitCallNode that allows us to pass another | |
| 1419 * already translated argument, visitCallNodeExtraArgument. However, we initially have | |
| 1420 * an AttrAssignNode, so we also need a special version of that. | |
| 1421 */ | |
| 1422 | |
| 1423 final org.jrubyparser.ast.AttrAssignNode dummyAttrAssignment = (org.jrubyparser.ast.AttrAssignNode) dummyAssignment; | |
| 1424 translated = visitAttrAssignNodeExtraArgument(dummyAttrAssignment, rhs); | |
| 1425 } else if (dummyAssignment instanceof org.jrubyparser.ast.DAsgnNode) { | |
| 1426 final RubyNode dummyTranslated = (RubyNode) dummyAssignment.accept(this); | |
| 1427 | |
| 1428 if (dummyTranslated.getNonProxyNode() instanceof WriteLevelVariableNode) { | |
| 1429 translated = ((ReadNode) ((WriteLevelVariableNode) dummyTranslated.getNonProxyNode()).makeReadNode()).makeWriteNode(rhs); | |
| 1430 } else { | |
| 1431 translated = ((ReadNode) ((WriteLocalVariableNode) dummyTranslated.getNonProxyNode()).makeReadNode()).makeWriteNode(rhs); | |
| 1432 } | |
| 1433 } else { | |
| 1434 translated = ((ReadNode) environment.findLocalVarNode(environment.allocateLocalTemp(), sourceSection)).makeWriteNode(rhs); | |
| 1435 } | |
| 1436 | |
| 1437 return translated; | |
| 1438 } | |
| 1439 | |
| 1440 @Override | |
| 1441 public Object visitNewlineNode(org.jrubyparser.ast.NewlineNode node) { | |
| 1442 RubyNode translated = (RubyNode) node.getNextNode().accept(this); | |
|
13735
2c1c805153e6
Ruby: refactor low level instrumentation services
Michael Van De Vanter <michael.van.de.vanter@oracle.com>
parents:
13732
diff
changeset
|
1443 return instrumenter.instrumentAsStatement(translated); |
| 13514 | 1444 } |
| 1445 | |
| 1446 @Override | |
| 1447 public Object visitNextNode(org.jrubyparser.ast.NextNode node) { | |
|
13556
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1448 final SourceSection sourceSection = translate(node.getPosition()); |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1449 |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1450 RubyNode resultNode; |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1451 |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1452 if (node.getValueNode() == null) { |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1453 resultNode = new NilNode(context, sourceSection); |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1454 } else { |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1455 resultNode = (RubyNode) node.getValueNode().accept(this); |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1456 } |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1457 |
|
44288fe54352
Ruby: fix some ?break? semantics.
Chris Seaton <chris.seaton@oracle.com>
parents:
13514
diff
changeset
|
1458 return new NextNode(context, sourceSection, resultNode); |
| 13514 | 1459 } |
| 1460 | |
| 1461 @Override | |
| 1462 public Object visitNilNode(org.jrubyparser.ast.NilNode node) { | |
| 1463 return new NilNode(context, translate(node.getPosition())); | |
| 1464 } | |
| 1465 | |
| 1466 @Override | |
| 1467 public Object visitNotNode(org.jrubyparser.ast.NotNode node) { | |
| 1468 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1469 | |
| 1470 final BooleanCastNode booleanCastNode = BooleanCastNodeFactory.create(context, sourceSection, (RubyNode) node.getCondition().accept(this)); | |
| 1471 | |
| 1472 return new NotNode(context, sourceSection, booleanCastNode); | |
| 1473 } | |
| 1474 | |
| 1475 @Override | |
| 1476 public Object visitNthRefNode(org.jrubyparser.ast.NthRefNode node) { | |
| 1477 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1478 | |
| 1479 final String name = "$" + node.getMatchNumber(); | |
| 1480 | |
| 1481 RubyNode readLocal = environment.findLocalVarNode(name, sourceSection); | |
| 1482 | |
| 1483 if (readLocal == null) { | |
| 1484 environment.declareVar(name); | |
| 1485 readLocal = environment.findLocalVarNode(name, sourceSection); | |
| 1486 } | |
| 1487 | |
| 1488 return readLocal; | |
| 1489 } | |
| 1490 | |
| 1491 @Override | |
| 1492 public Object visitOpAsgnAndNode(org.jrubyparser.ast.OpAsgnAndNode node) { | |
| 1493 final org.jrubyparser.ast.Node lhs = node.getFirst(); | |
| 1494 final org.jrubyparser.ast.Node rhs = node.getSecond(); | |
| 1495 | |
| 1496 return AndNodeFactory.create(context, translate(node.getPosition()), (RubyNode) lhs.accept(this), (RubyNode) rhs.accept(this)); | |
| 1497 } | |
| 1498 | |
| 1499 @Override | |
| 1500 public Object visitOpAsgnNode(org.jrubyparser.ast.OpAsgnNode node) { | |
| 1501 /* | |
| 1502 * We're going to de-sugar a.foo += c into a.foo = a.foo + c. Note that we can't evaluate a | |
| 1503 * more than once, so we put it into a temporary, and we're doing something more like: | |
| 1504 * | |
| 1505 * temp = a; temp.foo = temp.foo + c | |
| 1506 */ | |
| 1507 | |
| 1508 final String temp = environment.allocateLocalTemp(); | |
| 1509 final org.jrubyparser.ast.Node writeReceiverToTemp = new org.jrubyparser.ast.LocalAsgnNode(node.getPosition(), temp, 0, node.getReceiver()); | |
| 1510 final org.jrubyparser.ast.Node readReceiverFromTemp = new org.jrubyparser.ast.LocalVarNode(node.getPosition(), 0, temp); | |
| 1511 | |
| 1512 final org.jrubyparser.ast.Node readMethod = new org.jrubyparser.ast.CallNode(node.getPosition(), readReceiverFromTemp, node.getVariableName(), null); | |
| 1513 final org.jrubyparser.ast.Node operation = new org.jrubyparser.ast.CallNode(node.getPosition(), readMethod, node.getOperatorName(), buildArrayNode(node.getPosition(), node.getValue())); | |
| 1514 final org.jrubyparser.ast.Node writeMethod = new org.jrubyparser.ast.CallNode(node.getPosition(), readReceiverFromTemp, node.getVariableName() + "=", buildArrayNode(node.getPosition(), | |
| 1515 operation)); | |
| 1516 | |
| 1517 final org.jrubyparser.ast.BlockNode block = new org.jrubyparser.ast.BlockNode(node.getPosition()); | |
| 1518 block.add(writeReceiverToTemp); | |
| 1519 block.add(writeMethod); | |
| 1520 | |
| 1521 return block.accept(this); | |
| 1522 } | |
| 1523 | |
| 1524 @Override | |
| 1525 public Object visitOpAsgnOrNode(org.jrubyparser.ast.OpAsgnOrNode node) { | |
| 1526 /* | |
| 1527 * De-sugar x ||= y into x || x = y. No repeated evaluations there so it's easy. It's also | |
| 1528 * basically how jruby-parser represents it already. We'll do it directly, rather than via | |
| 1529 * another JRuby AST node. | |
| 1530 */ | |
| 1531 | |
| 1532 final org.jrubyparser.ast.Node lhs = node.getFirst(); | |
| 1533 final org.jrubyparser.ast.Node rhs = node.getSecond(); | |
| 1534 | |
| 1535 return OrNodeFactory.create(context, translate(node.getPosition()), (RubyNode) lhs.accept(this), (RubyNode) rhs.accept(this)); | |
| 1536 } | |
| 1537 | |
| 1538 @Override | |
| 1539 public Object visitOpElementAsgnNode(org.jrubyparser.ast.OpElementAsgnNode node) { | |
| 1540 /* | |
| 1541 * We're going to de-sugar a[b] += c into a[b] = a[b] + c. See discussion in | |
| 1542 * visitOpAsgnNode. | |
| 1543 */ | |
| 1544 | |
| 1545 org.jrubyparser.ast.Node index; | |
| 1546 | |
| 1547 if (node.getArgs() == null) { | |
| 1548 index = null; | |
| 1549 } else { | |
| 1550 index = node.getArgs().childNodes().get(0); | |
| 1551 } | |
| 1552 | |
| 1553 final org.jrubyparser.ast.Node operand = node.getValue(); | |
| 1554 | |
| 1555 final String temp = environment.allocateLocalTemp(); | |
| 1556 final org.jrubyparser.ast.Node writeArrayToTemp = new org.jrubyparser.ast.LocalAsgnNode(node.getPosition(), temp, 0, node.getReceiver()); | |
| 1557 final org.jrubyparser.ast.Node readArrayFromTemp = new org.jrubyparser.ast.LocalVarNode(node.getPosition(), 0, temp); | |
| 1558 | |
| 1559 final org.jrubyparser.ast.Node arrayRead = new org.jrubyparser.ast.CallNode(node.getPosition(), readArrayFromTemp, "[]", buildArrayNode(node.getPosition(), index)); | |
| 1560 | |
| 1561 final String op = node.getOperatorName(); | |
| 1562 | |
| 1563 org.jrubyparser.ast.Node operation = null; | |
| 1564 | |
| 1565 if (op.equals("||")) { | |
| 1566 operation = new org.jrubyparser.ast.OrNode(node.getPosition(), arrayRead, operand); | |
| 1567 } else if (op.equals("&&")) { | |
| 1568 operation = new org.jrubyparser.ast.AndNode(node.getPosition(), arrayRead, operand); | |
| 1569 } else { | |
| 1570 operation = new org.jrubyparser.ast.CallNode(node.getPosition(), arrayRead, node.getOperatorName(), buildArrayNode(node.getPosition(), operand)); | |
| 1571 } | |
| 1572 | |
| 1573 final org.jrubyparser.ast.Node arrayWrite = new org.jrubyparser.ast.CallNode(node.getPosition(), readArrayFromTemp, "[]=", buildArrayNode(node.getPosition(), index, operation)); | |
| 1574 | |
| 1575 final org.jrubyparser.ast.BlockNode block = new org.jrubyparser.ast.BlockNode(node.getPosition()); | |
| 1576 block.add(writeArrayToTemp); | |
| 1577 block.add(arrayWrite); | |
| 1578 | |
| 1579 return block.accept(this); | |
| 1580 } | |
| 1581 | |
| 1582 private static org.jrubyparser.ast.ArrayNode buildArrayNode(org.jrubyparser.SourcePosition sourcePosition, org.jrubyparser.ast.Node first, org.jrubyparser.ast.Node... rest) { | |
| 1583 if (first == null) { | |
| 1584 return new org.jrubyparser.ast.ArrayNode(sourcePosition); | |
| 1585 } | |
| 1586 | |
| 1587 final org.jrubyparser.ast.ArrayNode array = new org.jrubyparser.ast.ArrayNode(sourcePosition, first); | |
| 1588 | |
| 1589 for (org.jrubyparser.ast.Node node : rest) { | |
| 1590 array.add(node); | |
| 1591 } | |
| 1592 | |
| 1593 return array; | |
| 1594 } | |
| 1595 | |
| 1596 @Override | |
| 1597 public Object visitOrNode(org.jrubyparser.ast.OrNode node) { | |
| 1598 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1599 | |
| 1600 RubyNode x; | |
| 1601 | |
| 1602 if (node.getFirst() == null) { | |
| 1603 x = new NilNode(context, sourceSection); | |
| 1604 } else { | |
| 1605 x = (RubyNode) node.getFirst().accept(this); | |
| 1606 } | |
| 1607 | |
| 1608 RubyNode y; | |
| 1609 | |
| 1610 if (node.getSecond() == null) { | |
| 1611 y = new NilNode(context, sourceSection); | |
| 1612 } else { | |
| 1613 y = (RubyNode) node.getSecond().accept(this); | |
| 1614 } | |
| 1615 | |
| 1616 return OrNodeFactory.create(context, sourceSection, x, y); | |
| 1617 } | |
| 1618 | |
| 1619 @Override | |
| 1620 public Object visitPostExeNode(org.jrubyparser.ast.PostExeNode node) { | |
| 1621 return unimplemented(node); | |
| 1622 } | |
| 1623 | |
| 1624 @Override | |
| 1625 public Object visitPreExeNode(org.jrubyparser.ast.PreExeNode node) { | |
| 1626 return unimplemented(node); | |
| 1627 } | |
| 1628 | |
| 1629 @Override | |
| 1630 public Object visitRedoNode(org.jrubyparser.ast.RedoNode node) { | |
| 1631 return new RedoNode(context, translate(node.getPosition())); | |
| 1632 } | |
| 1633 | |
| 1634 @Override | |
| 1635 public Object visitRegexpNode(org.jrubyparser.ast.RegexpNode node) { | |
| 1636 RubyRegexp regexp; | |
| 1637 | |
| 1638 try { | |
| 1639 final String patternText = node.getValue(); | |
| 1640 | |
| 1641 int flags = Pattern.MULTILINE | Pattern.UNIX_LINES; | |
| 1642 | |
| 1643 final org.jrubyparser.RegexpOptions options = node.getOptions(); | |
| 1644 | |
| 1645 if (options.isIgnorecase()) { | |
| 1646 flags |= Pattern.CASE_INSENSITIVE; | |
| 1647 } | |
| 1648 | |
| 1649 if (options.isMultiline()) { | |
| 1650 // TODO(cs): isn't this the default? | |
| 1651 flags |= Pattern.MULTILINE; | |
| 1652 } | |
| 1653 | |
| 1654 final Pattern pattern = Pattern.compile(patternText, flags); | |
| 1655 | |
| 1656 regexp = new RubyRegexp(context.getCoreLibrary().getRegexpClass(), pattern); | |
| 1657 } catch (PatternSyntaxException e) { | |
| 1658 context.implementationMessage("failed to parse Ruby regexp " + node.getValue() + " as Java regexp - replacing with ."); | |
| 1659 regexp = new RubyRegexp(context.getCoreLibrary().getRegexpClass(), "."); | |
| 1660 } | |
| 1661 | |
| 1662 final ObjectLiteralNode literalNode = new ObjectLiteralNode(context, translate(node.getPosition()), regexp); | |
| 1663 return literalNode; | |
| 1664 } | |
| 1665 | |
| 1666 @Override | |
| 1667 public Object visitRescueBodyNode(org.jrubyparser.ast.RescueBodyNode node) { | |
| 1668 return unimplemented(node); | |
| 1669 } | |
| 1670 | |
| 1671 @Override | |
| 1672 public Object visitRescueNode(org.jrubyparser.ast.RescueNode node) { | |
| 1673 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1674 | |
| 1675 RubyNode tryPart; | |
| 1676 | |
| 1677 if (node.getBody() != null) { | |
| 1678 tryPart = (RubyNode) node.getBody().accept(this); | |
| 1679 } else { | |
| 1680 tryPart = new NilNode(context, sourceSection); | |
| 1681 } | |
| 1682 | |
| 1683 final List<RescueNode> rescueNodes = new ArrayList<>(); | |
| 1684 | |
| 1685 org.jrubyparser.ast.RescueBodyNode rescueBody = node.getRescue(); | |
| 1686 | |
| 1687 while (rescueBody != null) { | |
| 1688 if (rescueBody.getExceptions() != null) { | |
| 1689 if (rescueBody.getExceptions() instanceof org.jrubyparser.ast.ArrayNode) { | |
| 1690 final List<org.jrubyparser.ast.Node> exceptionNodes = ((org.jrubyparser.ast.ArrayNode) rescueBody.getExceptions()).childNodes(); | |
| 1691 | |
| 1692 final RubyNode[] handlingClasses = new RubyNode[exceptionNodes.size()]; | |
| 1693 | |
| 1694 for (int n = 0; n < handlingClasses.length; n++) { | |
| 1695 handlingClasses[n] = (RubyNode) exceptionNodes.get(n).accept(this); | |
| 1696 } | |
| 1697 | |
| 1698 RubyNode translatedBody; | |
| 1699 | |
| 1700 if (rescueBody.getBody() == null) { | |
| 1701 translatedBody = new NilNode(context, sourceSection); | |
| 1702 } else { | |
| 1703 translatedBody = (RubyNode) rescueBody.getBody().accept(this); | |
| 1704 } | |
| 1705 | |
| 1706 final RescueClassesNode rescueNode = new RescueClassesNode(context, sourceSection, handlingClasses, translatedBody); | |
| 1707 rescueNodes.add(rescueNode); | |
| 1708 } else if (rescueBody.getExceptions() instanceof org.jrubyparser.ast.SplatNode) { | |
| 1709 final org.jrubyparser.ast.SplatNode splat = (org.jrubyparser.ast.SplatNode) rescueBody.getExceptions(); | |
| 1710 | |
| 1711 RubyNode splatTranslated; | |
| 1712 | |
| 1713 if (splat.getValue() == null) { | |
| 1714 splatTranslated = new NilNode(context, sourceSection); | |
| 1715 } else { | |
| 1716 splatTranslated = (RubyNode) splat.getValue().accept(this); | |
| 1717 } | |
| 1718 | |
| 1719 RubyNode bodyTranslated; | |
| 1720 | |
| 1721 if (rescueBody.getBody() == null) { | |
| 1722 bodyTranslated = new NilNode(context, sourceSection); | |
| 1723 } else { | |
| 1724 bodyTranslated = (RubyNode) rescueBody.getBody().accept(this); | |
| 1725 } | |
| 1726 | |
| 1727 final RescueSplatNode rescueNode = new RescueSplatNode(context, sourceSection, splatTranslated, bodyTranslated); | |
| 1728 rescueNodes.add(rescueNode); | |
| 1729 } else { | |
| 1730 unimplemented(node); | |
| 1731 } | |
| 1732 } else { | |
| 1733 RubyNode bodyNode; | |
| 1734 | |
| 1735 if (rescueBody.getBody() == null) { | |
| 1736 bodyNode = new NilNode(context, sourceSection); | |
| 1737 } else { | |
| 1738 bodyNode = (RubyNode) rescueBody.getBody().accept(this); | |
| 1739 } | |
| 1740 | |
| 1741 final RescueAnyNode rescueNode = new RescueAnyNode(context, sourceSection, bodyNode); | |
| 1742 rescueNodes.add(rescueNode); | |
| 1743 } | |
| 1744 | |
| 1745 rescueBody = rescueBody.getOptRescue(); | |
| 1746 } | |
| 1747 | |
| 1748 RubyNode elsePart; | |
| 1749 | |
| 1750 if (node.getElse() != null) { | |
| 1751 elsePart = (RubyNode) node.getElse().accept(this); | |
| 1752 } else { | |
| 1753 elsePart = new NilNode(context, sourceSection); | |
| 1754 } | |
| 1755 | |
| 1756 return new TryNode(context, sourceSection, tryPart, rescueNodes.toArray(new RescueNode[rescueNodes.size()]), elsePart); | |
| 1757 } | |
| 1758 | |
| 1759 @Override | |
| 1760 public Object visitRestArgNode(org.jrubyparser.ast.RestArgNode node) { | |
| 1761 return unimplemented(node); | |
| 1762 } | |
| 1763 | |
| 1764 @Override | |
| 1765 public Object visitRetryNode(org.jrubyparser.ast.RetryNode node) { | |
| 1766 return new RetryNode(context, translate(node.getPosition())); | |
| 1767 } | |
| 1768 | |
| 1769 @Override | |
| 1770 public Object visitReturnNode(org.jrubyparser.ast.ReturnNode node) { | |
| 1771 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1772 | |
| 1773 RubyNode translatedChild; | |
| 1774 | |
| 1775 if (node.getValue() == null) { | |
| 1776 translatedChild = new NilNode(context, sourceSection); | |
| 1777 } else { | |
| 1778 translatedChild = (RubyNode) node.getValue().accept(this); | |
| 1779 } | |
| 1780 | |
| 1781 return new ReturnNode(context, sourceSection, environment.getReturnID(), translatedChild); | |
| 1782 } | |
| 1783 | |
| 1784 @Override | |
| 1785 public Object visitRootNode(org.jrubyparser.ast.RootNode node) { | |
| 1786 return unimplemented(node); | |
| 1787 } | |
| 1788 | |
| 1789 @Override | |
| 1790 public Object visitSClassNode(org.jrubyparser.ast.SClassNode node) { | |
| 1791 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1792 | |
| 1793 final TranslatorEnvironment newEnvironment = new TranslatorEnvironment(context, environment, environment.getParser(), environment.getParser().allocateReturnID(), true, true, | |
| 1794 new UniqueMethodIdentifier()); | |
| 1795 final ModuleTranslator classTranslator = new ModuleTranslator(context, this, newEnvironment, source); | |
| 1796 | |
| 1797 final MethodDefinitionNode definitionMethod = classTranslator.compileClassNode(node.getPosition(), "singleton", node.getBody()); | |
| 1798 | |
| 1799 final RubyNode receiverNode = (RubyNode) node.getReceiver().accept(this); | |
| 1800 | |
| 1801 final SingletonClassNode singletonClassNode = new SingletonClassNode(context, sourceSection, receiverNode); | |
| 1802 | |
| 1803 return new OpenModuleNode(context, sourceSection, singletonClassNode, definitionMethod); | |
| 1804 } | |
| 1805 | |
| 1806 @Override | |
| 1807 public Object visitSValueNode(org.jrubyparser.ast.SValueNode node) { | |
| 1808 return node.getValue().accept(this); | |
| 1809 } | |
| 1810 | |
| 1811 @Override | |
| 1812 public Object visitSelfNode(org.jrubyparser.ast.SelfNode node) { | |
| 1813 return new SelfNode(context, translate(node.getPosition())); | |
| 1814 } | |
| 1815 | |
| 1816 @Override | |
| 1817 public Object visitSplatNode(org.jrubyparser.ast.SplatNode node) { | |
| 1818 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1819 | |
| 1820 RubyNode value; | |
| 1821 | |
| 1822 if (node.getValue() == null) { | |
| 1823 value = new NilNode(context, sourceSection); | |
| 1824 } else { | |
| 1825 value = (RubyNode) node.getValue().accept(this); | |
| 1826 } | |
| 1827 | |
| 1828 return SplatCastNodeFactory.create(context, sourceSection, value); | |
| 1829 } | |
| 1830 | |
| 1831 @Override | |
| 1832 public Object visitStrNode(org.jrubyparser.ast.StrNode node) { | |
| 1833 return new StringLiteralNode(context, translate(node.getPosition()), node.getValue()); | |
| 1834 } | |
| 1835 | |
| 1836 @Override | |
| 1837 public Object visitSuperNode(org.jrubyparser.ast.SuperNode node) { | |
| 1838 return unimplemented(node); | |
| 1839 } | |
| 1840 | |
| 1841 @Override | |
| 1842 public Object visitSymbolNode(org.jrubyparser.ast.SymbolNode node) { | |
| 1843 return new ObjectLiteralNode(context, translate(node.getPosition()), new RubySymbol(context.getCoreLibrary().getSymbolClass(), node.getName())); | |
| 1844 } | |
| 1845 | |
| 1846 @Override | |
| 1847 public Object visitToAryNode(org.jrubyparser.ast.ToAryNode node) { | |
| 1848 return unimplemented(node); | |
| 1849 } | |
| 1850 | |
| 1851 @Override | |
| 1852 public Object visitTrueNode(org.jrubyparser.ast.TrueNode node) { | |
| 1853 return new BooleanLiteralNode(context, translate(node.getPosition()), true); | |
| 1854 } | |
| 1855 | |
| 1856 @Override | |
| 1857 public Object visitUndefNode(org.jrubyparser.ast.UndefNode node) { | |
| 1858 return unimplemented(node); | |
| 1859 } | |
| 1860 | |
| 1861 @Override | |
| 1862 public Object visitUntilNode(org.jrubyparser.ast.UntilNode node) { | |
| 1863 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1864 | |
| 1865 RubyNode condition; | |
| 1866 | |
| 1867 if (node.getCondition() == null) { | |
| 1868 condition = new NilNode(context, sourceSection); | |
| 1869 } else { | |
| 1870 condition = (RubyNode) node.getCondition().accept(this); | |
| 1871 } | |
| 1872 | |
| 1873 final BooleanCastNode conditionCast = BooleanCastNodeFactory.create(context, sourceSection, condition); | |
| 1874 final NotNode conditionCastNot = new NotNode(context, sourceSection, conditionCast); | |
| 1875 final BooleanCastNode conditionCastNotCast = BooleanCastNodeFactory.create(context, sourceSection, conditionCastNot); | |
| 1876 | |
| 1877 final RubyNode body = (RubyNode) node.getBody().accept(this); | |
| 1878 | |
| 1879 return new WhileNode(context, sourceSection, conditionCastNotCast, body); | |
| 1880 } | |
| 1881 | |
| 1882 @Override | |
| 1883 public Object visitVAliasNode(org.jrubyparser.ast.VAliasNode node) { | |
| 1884 return unimplemented(node); | |
| 1885 } | |
| 1886 | |
| 1887 @Override | |
| 1888 public Object visitVCallNode(org.jrubyparser.ast.VCallNode node) { | |
| 1889 final org.jrubyparser.ast.Node receiver = new org.jrubyparser.ast.SelfNode(node.getPosition()); | |
| 1890 final org.jrubyparser.ast.Node args = null; | |
| 1891 final org.jrubyparser.ast.Node callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), receiver, node.getName(), args); | |
| 1892 | |
| 1893 return callNode.accept(this); | |
| 1894 } | |
| 1895 | |
| 1896 @Override | |
| 1897 public Object visitWhenNode(org.jrubyparser.ast.WhenNode node) { | |
| 1898 return unimplemented(node); | |
| 1899 } | |
| 1900 | |
| 1901 @Override | |
| 1902 public Object visitWhileNode(org.jrubyparser.ast.WhileNode node) { | |
| 1903 final SourceSection sourceSection = translate(node.getPosition()); | |
| 1904 | |
| 1905 RubyNode condition; | |
| 1906 | |
| 1907 if (node.getCondition() == null) { | |
| 1908 condition = new NilNode(context, sourceSection); | |
| 1909 } else { | |
| 1910 condition = (RubyNode) node.getCondition().accept(this); | |
| 1911 } | |
| 1912 | |
| 1913 final BooleanCastNode conditionCast = BooleanCastNodeFactory.create(context, sourceSection, condition); | |
| 1914 | |
| 1915 final RubyNode body = (RubyNode) node.getBody().accept(this); | |
| 1916 | |
| 1917 return new WhileNode(context, sourceSection, conditionCast, body); | |
| 1918 } | |
| 1919 | |
| 1920 @Override | |
| 1921 public Object visitXStrNode(org.jrubyparser.ast.XStrNode node) { | |
| 1922 SourceSection sourceSection = translate(node.getPosition()); | |
| 1923 | |
| 1924 final StringLiteralNode literal = new StringLiteralNode(context, sourceSection, node.getValue()); | |
| 1925 | |
| 1926 return new SystemNode(context, sourceSection, literal); | |
| 1927 } | |
| 1928 | |
| 1929 @Override | |
| 1930 public Object visitYieldNode(org.jrubyparser.ast.YieldNode node) { | |
| 1931 final List<org.jrubyparser.ast.Node> arguments = new ArrayList<>(); | |
| 1932 | |
| 1933 final org.jrubyparser.ast.Node argsNode = node.getArgs(); | |
| 1934 | |
| 1935 if (argsNode != null) { | |
| 1936 if (argsNode instanceof org.jrubyparser.ast.ListNode) { | |
| 1937 arguments.addAll(((org.jrubyparser.ast.ListNode) node.getArgs()).childNodes()); | |
| 1938 } else { | |
| 1939 arguments.add(node.getArgs()); | |
| 1940 } | |
| 1941 } | |
| 1942 | |
| 1943 final List<RubyNode> argumentsTranslated = new ArrayList<>(); | |
| 1944 | |
| 1945 for (org.jrubyparser.ast.Node argument : arguments) { | |
| 1946 argumentsTranslated.add((RubyNode) argument.accept(this)); | |
| 1947 } | |
| 1948 | |
| 1949 final RubyNode[] argumentsTranslatedArray = argumentsTranslated.toArray(new RubyNode[argumentsTranslated.size()]); | |
| 1950 | |
| 1951 return new YieldNode(context, translate(node.getPosition()), argumentsTranslatedArray); | |
| 1952 } | |
| 1953 | |
| 1954 @Override | |
| 1955 public Object visitZArrayNode(org.jrubyparser.ast.ZArrayNode node) { | |
| 1956 final RubyNode[] values = new RubyNode[0]; | |
| 1957 | |
| 1958 return new UninitialisedArrayLiteralNode(context, translate(node.getPosition()), values); | |
| 1959 } | |
| 1960 | |
| 1961 @Override | |
| 1962 public Object visitZSuperNode(org.jrubyparser.ast.ZSuperNode node) { | |
| 1963 return unimplemented(node); | |
| 1964 } | |
| 1965 | |
| 1966 public Object visitArgumentNode(org.jrubyparser.ast.ArgumentNode node) { | |
| 1967 return unimplemented(node); | |
| 1968 } | |
| 1969 | |
| 1970 public Object visitCommentNode(org.jrubyparser.ast.CommentNode node) { | |
| 1971 return unimplemented(node); | |
| 1972 } | |
| 1973 | |
| 1974 public Object visitKeywordArgNode(org.jrubyparser.ast.KeywordArgNode node) { | |
| 1975 return unimplemented(node); | |
| 1976 } | |
| 1977 | |
| 1978 public Object visitKeywordRestArgNode(org.jrubyparser.ast.KeywordRestArgNode node) { | |
| 1979 return unimplemented(node); | |
| 1980 } | |
| 1981 | |
| 1982 public Object visitListNode(org.jrubyparser.ast.ListNode node) { | |
| 1983 return unimplemented(node); | |
| 1984 } | |
| 1985 | |
| 1986 public Object visitMethodNameNode(org.jrubyparser.ast.MethodNameNode node) { | |
| 1987 return unimplemented(node); | |
| 1988 } | |
| 1989 | |
| 1990 public Object visitOptArgNode(org.jrubyparser.ast.OptArgNode node) { | |
| 1991 return unimplemented(node); | |
| 1992 } | |
| 1993 | |
| 1994 public Object visitSyntaxNode(org.jrubyparser.ast.SyntaxNode node) { | |
| 1995 return unimplemented(node); | |
| 1996 } | |
| 1997 | |
| 1998 public Object visitImplicitNilNode(org.jrubyparser.ast.ImplicitNilNode node) { | |
| 1999 return new NilNode(context, translate(node.getPosition())); | |
| 2000 } | |
| 2001 | |
| 2002 public Object visitLambdaNode(org.jrubyparser.ast.LambdaNode node) { | |
| 2003 // TODO(cs): code copied and modified from visitIterNode - extract common | |
| 2004 | |
| 2005 final TranslatorEnvironment newEnvironment = new TranslatorEnvironment(context, environment, environment.getParser(), environment.getReturnID(), false, false, new UniqueMethodIdentifier()); | |
| 2006 final MethodTranslator methodCompiler = new MethodTranslator(context, this, newEnvironment, false, source); | |
| 2007 | |
| 2008 org.jrubyparser.ast.ArgsNode argsNode; | |
| 2009 | |
| 2010 if (node.getVar() instanceof org.jrubyparser.ast.ArgsNode) { | |
| 2011 argsNode = (org.jrubyparser.ast.ArgsNode) node.getVar(); | |
| 2012 } else if (node.getVar() instanceof org.jrubyparser.ast.DAsgnNode) { | |
| 2013 final org.jrubyparser.ast.ArgumentNode arg = new org.jrubyparser.ast.ArgumentNode(node.getPosition(), ((org.jrubyparser.ast.DAsgnNode) node.getVar()).getName()); | |
| 2014 final org.jrubyparser.ast.ListNode preArgs = new org.jrubyparser.ast.ArrayNode(node.getPosition(), arg); | |
| 2015 argsNode = new org.jrubyparser.ast.ArgsNode(node.getPosition(), preArgs, null, null, null, null, null, null); | |
| 2016 } else if (node.getVar() == null) { | |
| 2017 argsNode = null; | |
| 2018 } else { | |
| 2019 throw new UnsupportedOperationException(); | |
| 2020 } | |
| 2021 | |
| 2022 final MethodDefinitionNode definitionNode = methodCompiler.compileFunctionNode(translate(node.getPosition()), "(lambda)", argsNode, node.getBody()); | |
| 2023 | |
| 2024 return new LambdaNode(context, translate(node.getPosition()), definitionNode); | |
| 2025 } | |
| 2026 | |
| 2027 public Object visitUnaryCallNode(org.jrubyparser.ast.UnaryCallNode node) { | |
| 2028 final org.jrubyparser.ast.Node callNode = new org.jrubyparser.ast.CallNode(node.getPosition(), node.getReceiver(), node.getName(), null, null); | |
| 2029 return callNode.accept(this); | |
| 2030 } | |
| 2031 | |
| 2032 protected Object unimplemented(org.jrubyparser.ast.Node node) { | |
| 2033 context.implementationMessage("warning: %s at %s does nothing", node, node.getPosition()); | |
| 2034 return new NilNode(context, translate(node.getPosition())); | |
| 2035 } | |
| 2036 | |
| 2037 protected SourceSection translate(final org.jrubyparser.SourcePosition sourcePosition) { | |
| 2038 try { | |
| 2039 // TODO(cs): get an identifier | |
| 2040 final String identifier = "(identifier)"; | |
| 2041 | |
| 2042 // TODO(cs): work out the start column | |
| 2043 final int startColumn = -1; | |
| 2044 | |
| 2045 final int charLength = sourcePosition.getEndOffset() - sourcePosition.getStartOffset(); | |
| 2046 | |
| 2047 return new DefaultSourceSection(source, identifier, sourcePosition.getStartLine() + 1, startColumn, sourcePosition.getStartOffset(), charLength); | |
| 2048 } catch (UnsupportedOperationException e) { | |
| 2049 // In some circumstances JRuby can't tell you what the position is | |
| 2050 return translate(new org.jrubyparser.SourcePosition("(unknown)", 0, 0)); | |
| 2051 } | |
| 2052 } | |
| 2053 | |
| 2054 protected SequenceNode initFlipFlopStates(SourceSection sourceSection) { | |
| 2055 final RubyNode[] initNodes = new RubyNode[environment.getFlipFlopStates().size()]; | |
| 2056 | |
| 2057 for (int n = 0; n < initNodes.length; n++) { | |
| 2058 initNodes[n] = new InitFlipFlopSlotNode(context, sourceSection, environment.getFlipFlopStates().get(n)); | |
| 2059 } | |
| 2060 | |
| 2061 return new SequenceNode(context, sourceSection, initNodes); | |
| 2062 } | |
| 2063 | |
| 2064 } |