ASTCompiler

java.lang.Object
- org.jruby.compiler.ASTCompiler

Direct Known Subclasses:: ASTCompiler19

public class ASTCompiler
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`ASTCompiler.OpElementAsgnArgumentsCallback`
`class`	`ASTCompiler.SpecificArityArguments`
`class`	`ASTCompiler.VariableArityArguments`

Field Summary

Fields
Modifier and Type	Field and Description
`private Node`	`currentBodyNode`
`private static java.util.Map<java.lang.Class,java.util.Map<java.lang.Class,java.util.Map<java.lang.String,java.lang.String>>>`	`Intrinsics`
`private boolean`	`isAtRoot`

Constructor Summary

Constructors
Constructor and Description

ASTCompiler()

Constructors
Constructor and Description
`ASTCompiler()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addConditionalForWhen(WhenNode whenNode, java.util.List<ArgumentsCallback> conditionals, java.util.List<CompilerCallback> bodies, CompilerCallback body)`
`private void`	`becomeTrueOrFalse(BodyCompiler context)`
`void`	`compile(Node node, BodyCompiler context, boolean expr)`
`void`	`compileAlias(AliasNode alias, BodyCompiler context, boolean expr)`
`void`	`compileAnd(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArgs(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArgsCat(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArgsCatArguments(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArgsPush(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArgsPushArguments(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArguments(Node node, BodyCompiler context)`
`void`	`compileArray(Node node, BodyCompiler context, boolean expr)`
`void`	`compileArrayArguments(Node node, BodyCompiler context, boolean expr)`
`void`	`compileAssignment(Node node, BodyCompiler context)`
`private void`	`compileAttrAssign(Node node, BodyCompiler context, boolean expr)`
`void`	`compileAttrAssignAssignment(Node node, BodyCompiler context)`
`void`	`compileBackref(Node node, BodyCompiler context, boolean expr)`
`void`	`compileBegin(Node node, BodyCompiler context, boolean expr)`
`void`	`compileBignum(Node node, BodyCompiler context, boolean expr)`
`void`	`compileBlock(Node node, BodyCompiler context, boolean expr)`
`void`	`compileBody(Node node, BodyCompiler context, boolean expr)`
`void`	`compileBreak(Node node, BodyCompiler context, boolean expr)`
`void`	`compileCall(Node node, BodyCompiler context, boolean expr)`
`void`	`compileCase(Node node, BodyCompiler context, boolean expr)`
`void`	`compileClass(Node node, BodyCompiler context, boolean expr)`
`void`	`compileClassVar(Node node, BodyCompiler context, boolean expr)`
`void`	`compileClassVarAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileClassVarAsgnAssignment(Node node, BodyCompiler context)`
`void`	`compileClassVarDecl(Node node, BodyCompiler context, boolean expr)`
`void`	`compileClassVarDeclAssignment(Node node, BodyCompiler context)`
`void`	`compileColon2(Node node, BodyCompiler context, boolean expr)`
`void`	`compileColon3(Node node, BodyCompiler context, boolean expr)`
`void`	`compileCondition(Node node, BodyCompiler context, boolean expr)`
`void`	`compileConst(Node node, BodyCompiler context, boolean expr)`
`void`	`compileConstDecl(Node node, BodyCompiler context, boolean expr)`
`void`	`compileConstDeclAssignment(Node node, BodyCompiler context)`
`void`	`compileDAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDAsgnAssignment(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDefined(Node node, BodyCompiler context, boolean expr)`
`protected void`	`compileDefinedAndOrDStrDRegexp(Node node, BodyCompiler context)`
`protected void`	`compileDefinedBackref(Node node, BodyCompiler context)`
`protected void`	`compileDefinedCall(Node node, BodyCompiler context)`
`protected void`	`compileDefinedDVar(Node node, BodyCompiler context)`
`protected void`	`compileDefinedNthref(Node node, BodyCompiler context)`
`void`	`compileDefn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDefs(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDNode(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDot(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDRegexp(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDStr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDSymbol(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDVar(Node node, BodyCompiler context, boolean expr)`
`void`	`compileDXStr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileEnsureNode(Node node, BodyCompiler context, boolean expr)`
`void`	`compileEvStr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileFalse(Node node, BodyCompiler context, boolean expr)`
`void`	`compileFCall(Node node, BodyCompiler context, boolean expr)`
`void`	`compileFixnum(Node node, BodyCompiler context, boolean expr)`
`void`	`compileFlip(Node node, BodyCompiler context, boolean expr)`
`void`	`compileFloat(Node node, BodyCompiler context, boolean expr)`
`void`	`compileFor(Node node, BodyCompiler context, boolean expr)`
`void`	`compileForIter(Node node, BodyCompiler context)`
`void`	`compileGetArgumentDefinition(Node node, BodyCompiler context, java.lang.String type)`
`void`	`compileGetDefinition(Node node, BodyCompiler context)`
`void`	`compileGetDefinitionBase(Node node, BodyCompiler context)`
`void`	`compileGlobalAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileGlobalAsgnAssignment(Node node, BodyCompiler context)`
`void`	`compileGlobalVar(Node node, BodyCompiler context, boolean expr)`
`void`	`compileHash(Node node, BodyCompiler context, boolean expr)`
`protected void`	`compileHashCommon(HashNode hashNode, BodyCompiler context, boolean expr)`
`void`	`compileIf(Node node, BodyCompiler context, boolean expr)`
`void`	`compileInstAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileInstAsgnAssignment(Node node, BodyCompiler context)`
`void`	`compileInstVar(Node node, BodyCompiler context, boolean expr)`
`void`	`compileIter(Node node, BodyCompiler context)`
`void`	`compileLiteral(LiteralNode literal, BodyCompiler context)`
`void`	`compileLocalAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileLocalAsgnAssignment(Node node, BodyCompiler context, boolean expr)`
`void`	`compileLocalVar(Node node, BodyCompiler context, boolean expr)`
`void`	`compileMatch(Node node, BodyCompiler context, boolean expr)`
`void`	`compileMatch2(Node node, BodyCompiler context, boolean expr)`
`void`	`compileMatch3(Node node, BodyCompiler context, boolean expr)`
`void`	`compileModule(Node node, BodyCompiler context, boolean expr)`
`void`	`compileMultipleAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileMultipleAsgnAssignment(Node node, BodyCompiler context, boolean expr)`
`void`	`compileNewline(Node node, BodyCompiler context, boolean expr)`
`void`	`compileNext(Node node, BodyCompiler context, boolean expr)`
`void`	`compileNil(Node node, BodyCompiler context, boolean expr)`
`void`	`compileNot(Node node, BodyCompiler context, boolean expr)`
`void`	`compileNthRef(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpAsgnAnd(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpAsgnOr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpAsgnWithAnd(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpAsgnWithMethod(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpAsgnWithOr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpElementAsgn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpElementAsgnWithAnd(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpElementAsgnWithMethod(Node node, BodyCompiler context, boolean expr)`
`void`	`compileOpElementAsgnWithOr(Node node, BodyCompiler context, boolean expr)`
`private void`	`compileOptimizedMultipleAsgn(MultipleAsgnNode multipleAsgnNode, BodyCompiler context, boolean expr)`
`void`	`compileOr(Node node, BodyCompiler context, boolean expr)`
`void`	`compilePostExe(Node node, BodyCompiler context, boolean expr)`
`void`	`compilePreExe(Node node, BodyCompiler context, boolean expr)`
`void`	`compileRedo(Node node, BodyCompiler context, boolean expr)`
`void`	`compileRegexp(Node node, BodyCompiler context, boolean expr)`
`void`	`compileRescue(Node node, BodyCompiler context, boolean expr)`
`private void`	`compileRescueBodyInternal(Node node, BodyCompiler context, boolean light)`
`private void`	`compileRescueInternal(Node node, BodyCompiler context, boolean light)`
`void`	`compileRetry(Node node, BodyCompiler context, boolean expr)`
`void`	`compileReturn(Node node, BodyCompiler context, boolean expr)`
`void`	`compileRoot(Node node, ScriptCompiler context, ASTInspector inspector)`
`void`	`compileRoot(Node node, ScriptCompiler context, ASTInspector inspector, boolean load, boolean main)`
`void`	`compileSClass(Node node, BodyCompiler context, boolean expr)`
`void`	`compileSelf(Node node, BodyCompiler context, boolean expr)`
`void`	`compileSplat(Node node, BodyCompiler context, boolean expr)`
`void`	`compileSplatArguments(Node node, BodyCompiler context, boolean expr)`
`void`	`compileStr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileSuper(Node node, BodyCompiler context, boolean expr)`
`void`	`compileSValue(Node node, BodyCompiler context, boolean expr)`
`void`	`compileSymbol(Node node, BodyCompiler context, boolean expr)`
`void`	`compileToAry(Node node, BodyCompiler context, boolean expr)`
`void`	`compileTrue(Node node, BodyCompiler context, boolean expr)`
`void`	`compileUndef(UndefNode undef, BodyCompiler context, boolean expr)`
`private void`	`compileUnoptimizedMultipleAsgn(MultipleAsgnNode multipleAsgnNode, BodyCompiler context, boolean expr)`
`void`	`compileUntil(Node node, BodyCompiler context, boolean expr)`
`void`	`compileVAlias(Node node, BodyCompiler context, boolean expr)`
`void`	`compileVCall(Node node, BodyCompiler context, boolean expr)`
`void`	`compileWhen(Node value, java.util.List<Node> whenNodes, Node elseNode, BodyCompiler context, boolean expr, boolean outline)`
`void`	`compileWhile(Node node, BodyCompiler context, boolean expr)`
`void`	`compileXStr(Node node, BodyCompiler context, boolean expr)`
`void`	`compileYield(Node node, BodyCompiler context, boolean expr)`
`void`	`compileZArray(Node node, BodyCompiler context, boolean expr)`
`void`	`compileZSuper(Node node, BodyCompiler context, boolean expr)`
`protected void`	`createNewHash(BodyCompiler context, HashNode hashNode, ArrayCallback hashCallback)`
`private void`	`flipTrueOrFalse(BodyCompiler context)`
`ArgumentsCallback`	`getArgsCallback(Node node)`
`private CompilerCallback`	`getBlock(Node node)`
`private FastSwitchType`	`getHomogeneousSwitchType(java.util.List<Node> whenNodes)`
`private java.lang.String`	`getLiteralSend(CallNode callNode)`
`private int[]`	`getOptimizedCases(WhenNode whenNode)`
`protected boolean`	`is1_9()`
`private boolean`	`isListAllLiterals(ListNode listNode)`
`private boolean`	`needsDefinitionCheck(Node node)` Check whether the given node is considered always "defined" or whether it has some form of definition check.
`protected void`	`splatCurrentValue(BodyCompiler context)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

isAtRoot
```
private boolean isAtRoot
```

Intrinsics

private static final java.util.Map<java.lang.Class,java.util.Map<java.lang.Class,java.util.Map<java.lang.String,java.lang.String>>> Intrinsics

currentBodyNode
```
private Node currentBodyNode
```

Constructor Detail
- ASTCompiler
```
public ASTCompiler()
```

Method Detail

is1_9
```
protected boolean is1_9()
```

compileBody

public void compileBody(Node node,
                        BodyCompiler context,
                        boolean expr)

compile

public void compile(Node node,
                    BodyCompiler context,
                    boolean expr)

compileArguments

public void compileArguments(Node node,
                             BodyCompiler context)

getArgsCallback

public ArgumentsCallback getArgsCallback(Node node)

compileAssignment

public void compileAssignment(Node node,
                              BodyCompiler context)

compileAlias

public void compileAlias(AliasNode alias,
                         BodyCompiler context,
                         boolean expr)

compileAnd

public void compileAnd(Node node,
                       BodyCompiler context,
                       boolean expr)

compileArray

public void compileArray(Node node,
                         BodyCompiler context,
                         boolean expr)

isListAllLiterals

private boolean isListAllLiterals(ListNode listNode)

compileArgsCat

public void compileArgsCat(Node node,
                           BodyCompiler context,
                           boolean expr)

compileArgsPush

public void compileArgsPush(Node node,
                            BodyCompiler context,
                            boolean expr)

compileAttrAssign

private void compileAttrAssign(Node node,
                               BodyCompiler context,
                               boolean expr)

compileAttrAssignAssignment

public void compileAttrAssignAssignment(Node node,
                                        BodyCompiler context)

compileBackref

public void compileBackref(Node node,
                           BodyCompiler context,
                           boolean expr)

compileBegin

public void compileBegin(Node node,
                         BodyCompiler context,
                         boolean expr)

compileBignum

public void compileBignum(Node node,
                          BodyCompiler context,
                          boolean expr)

compileBlock

public void compileBlock(Node node,
                         BodyCompiler context,
                         boolean expr)

compileBreak

public void compileBreak(Node node,
                         BodyCompiler context,
                         boolean expr)

compileCall

public void compileCall(Node node,
                        BodyCompiler context,
                        boolean expr)

getLiteralSend

private java.lang.String getLiteralSend(CallNode callNode)

compileCase

public void compileCase(Node node,
                        BodyCompiler context,
                        boolean expr)

getHomogeneousSwitchType

private FastSwitchType getHomogeneousSwitchType(java.util.List<Node> whenNodes)

compileWhen

public void compileWhen(Node value,
                        java.util.List<Node> whenNodes,
                        Node elseNode,
                        BodyCompiler context,
                        boolean expr,
                        boolean outline)

getOptimizedCases

private int[] getOptimizedCases(WhenNode whenNode)

addConditionalForWhen

private void addConditionalForWhen(WhenNode whenNode,
                                   java.util.List<ArgumentsCallback> conditionals,
                                   java.util.List<CompilerCallback> bodies,
                                   CompilerCallback body)

compileClass

public void compileClass(Node node,
                         BodyCompiler context,
                         boolean expr)

compileSClass

public void compileSClass(Node node,
                          BodyCompiler context,
                          boolean expr)

compileClassVar

public void compileClassVar(Node node,
                            BodyCompiler context,
                            boolean expr)

compileClassVarAsgn

public void compileClassVarAsgn(Node node,
                                BodyCompiler context,
                                boolean expr)

compileClassVarAsgnAssignment

public void compileClassVarAsgnAssignment(Node node,
                                          BodyCompiler context)

compileClassVarDecl

public void compileClassVarDecl(Node node,
                                BodyCompiler context,
                                boolean expr)

compileClassVarDeclAssignment

public void compileClassVarDeclAssignment(Node node,
                                          BodyCompiler context)

compileConstDecl

public void compileConstDecl(Node node,
                             BodyCompiler context,
                             boolean expr)

compileConstDeclAssignment

public void compileConstDeclAssignment(Node node,
                                       BodyCompiler context)

compileConst

public void compileConst(Node node,
                         BodyCompiler context,
                         boolean expr)

compileColon2

public void compileColon2(Node node,
                          BodyCompiler context,
                          boolean expr)

compileColon3

public void compileColon3(Node node,
                          BodyCompiler context,
                          boolean expr)

compileGetDefinitionBase

public void compileGetDefinitionBase(Node node,
                                     BodyCompiler context)

compileDefined

public void compileDefined(Node node,
                           BodyCompiler context,
                           boolean expr)

compileGetArgumentDefinition

public void compileGetArgumentDefinition(Node node,
                                         BodyCompiler context,
                                         java.lang.String type)

compileGetDefinition

public void compileGetDefinition(Node node,
                                 BodyCompiler context)

compileDefinedAndOrDStrDRegexp

protected void compileDefinedAndOrDStrDRegexp(Node node,
                                              BodyCompiler context)

compileDefinedCall

protected void compileDefinedCall(Node node,
                                  BodyCompiler context)

compileDefinedDVar

protected void compileDefinedDVar(Node node,
                                  BodyCompiler context)

compileDefinedBackref

protected void compileDefinedBackref(Node node,
                                     BodyCompiler context)

compileDefinedNthref

protected void compileDefinedNthref(Node node,
                                    BodyCompiler context)

compileDAsgn

public void compileDAsgn(Node node,
                         BodyCompiler context,
                         boolean expr)

compileDAsgnAssignment

public void compileDAsgnAssignment(Node node,
                                   BodyCompiler context,
                                   boolean expr)

compileDefn

public void compileDefn(Node node,
                        BodyCompiler context,
                        boolean expr)

compileDefs

public void compileDefs(Node node,
                        BodyCompiler context,
                        boolean expr)

compileArgs

public void compileArgs(Node node,
                        BodyCompiler context,
                        boolean expr)

compileDot

public void compileDot(Node node,
                       BodyCompiler context,
                       boolean expr)

compileDRegexp

public void compileDRegexp(Node node,
                           BodyCompiler context,
                           boolean expr)

compileDNode

public void compileDNode(Node node,
                         BodyCompiler context,
                         boolean expr)

compileDStr

public void compileDStr(Node node,
                        BodyCompiler context,
                        boolean expr)

compileDSymbol

public void compileDSymbol(Node node,
                           BodyCompiler context,
                           boolean expr)

compileDVar

public void compileDVar(Node node,
                        BodyCompiler context,
                        boolean expr)

compileDXStr

public void compileDXStr(Node node,
                         BodyCompiler context,
                         boolean expr)

compileEnsureNode

public void compileEnsureNode(Node node,
                              BodyCompiler context,
                              boolean expr)

compileEvStr

public void compileEvStr(Node node,
                         BodyCompiler context,
                         boolean expr)

compileFalse

public void compileFalse(Node node,
                         BodyCompiler context,
                         boolean expr)

compileFCall

public void compileFCall(Node node,
                         BodyCompiler context,
                         boolean expr)

getBlock

private CompilerCallback getBlock(Node node)

compileFixnum

public void compileFixnum(Node node,
                          BodyCompiler context,
                          boolean expr)

compileFlip

public void compileFlip(Node node,
                        BodyCompiler context,
                        boolean expr)

becomeTrueOrFalse

private void becomeTrueOrFalse(BodyCompiler context)

flipTrueOrFalse

private void flipTrueOrFalse(BodyCompiler context)

compileFloat

public void compileFloat(Node node,
                         BodyCompiler context,
                         boolean expr)

compileFor

public void compileFor(Node node,
                       BodyCompiler context,
                       boolean expr)

compileForIter

public void compileForIter(Node node,
                           BodyCompiler context)

compileGlobalAsgn

public void compileGlobalAsgn(Node node,
                              BodyCompiler context,
                              boolean expr)

compileGlobalAsgnAssignment

public void compileGlobalAsgnAssignment(Node node,
                                        BodyCompiler context)

compileGlobalVar

public void compileGlobalVar(Node node,
                             BodyCompiler context,
                             boolean expr)

compileHash

public void compileHash(Node node,
                        BodyCompiler context,
                        boolean expr)

compileHashCommon

protected void compileHashCommon(HashNode hashNode,
                                 BodyCompiler context,
                                 boolean expr)

createNewHash

protected void createNewHash(BodyCompiler context,
                             HashNode hashNode,
                             ArrayCallback hashCallback)

compileIf

public void compileIf(Node node,
                      BodyCompiler context,
                      boolean expr)

compileCondition

public void compileCondition(Node node,
                             BodyCompiler context,
                             boolean expr)

compileInstAsgn

public void compileInstAsgn(Node node,
                            BodyCompiler context,
                            boolean expr)

compileInstAsgnAssignment

public void compileInstAsgnAssignment(Node node,
                                      BodyCompiler context)

compileInstVar

public void compileInstVar(Node node,
                           BodyCompiler context,
                           boolean expr)

compileIter

public void compileIter(Node node,
                        BodyCompiler context)

compileLiteral

public void compileLiteral(LiteralNode literal,
                           BodyCompiler context)

compileLocalAsgn

public void compileLocalAsgn(Node node,
                             BodyCompiler context,
                             boolean expr)

compileLocalAsgnAssignment

public void compileLocalAsgnAssignment(Node node,
                                       BodyCompiler context,
                                       boolean expr)

compileLocalVar

public void compileLocalVar(Node node,
                            BodyCompiler context,
                            boolean expr)

compileMatch

public void compileMatch(Node node,
                         BodyCompiler context,
                         boolean expr)

compileMatch2

public void compileMatch2(Node node,
                          BodyCompiler context,
                          boolean expr)

compileMatch3

public void compileMatch3(Node node,
                          BodyCompiler context,
                          boolean expr)

compileModule

public void compileModule(Node node,
                          BodyCompiler context,
                          boolean expr)

compileMultipleAsgn

public void compileMultipleAsgn(Node node,
                                BodyCompiler context,
                                boolean expr)

compileOptimizedMultipleAsgn

private void compileOptimizedMultipleAsgn(MultipleAsgnNode multipleAsgnNode,
                                          BodyCompiler context,
                                          boolean expr)

compileUnoptimizedMultipleAsgn

private void compileUnoptimizedMultipleAsgn(MultipleAsgnNode multipleAsgnNode,
                                            BodyCompiler context,
                                            boolean expr)

compileMultipleAsgnAssignment

public void compileMultipleAsgnAssignment(Node node,
                                          BodyCompiler context,
                                          boolean expr)

compileNewline

public void compileNewline(Node node,
                           BodyCompiler context,
                           boolean expr)

compileNext

public void compileNext(Node node,
                        BodyCompiler context,
                        boolean expr)

compileNthRef

public void compileNthRef(Node node,
                          BodyCompiler context,
                          boolean expr)

compileNil

public void compileNil(Node node,
                       BodyCompiler context,
                       boolean expr)

compileNot

public void compileNot(Node node,
                       BodyCompiler context,
                       boolean expr)

compileOpAsgnAnd

public void compileOpAsgnAnd(Node node,
                             BodyCompiler context,
                             boolean expr)

compileOpAsgnOr

public void compileOpAsgnOr(Node node,
                            BodyCompiler context,
                            boolean expr)

needsDefinitionCheck
```
private boolean needsDefinitionCheck(Node node)
```
Check whether the given node is considered always "defined" or whether it has some form of definition check.

Parameters:

node - Then node to check

Returns:

Whether the type of node represents a possibly undefined construct

compileOpAsgn

public void compileOpAsgn(Node node,
                          BodyCompiler context,
                          boolean expr)

compileOpAsgnWithOr

public void compileOpAsgnWithOr(Node node,
                                BodyCompiler context,
                                boolean expr)

compileOpAsgnWithAnd

public void compileOpAsgnWithAnd(Node node,
                                 BodyCompiler context,
                                 boolean expr)

compileOpAsgnWithMethod

public void compileOpAsgnWithMethod(Node node,
                                    BodyCompiler context,
                                    boolean expr)

compileOpElementAsgn

public void compileOpElementAsgn(Node node,
                                 BodyCompiler context,
                                 boolean expr)

compileOpElementAsgnWithOr

public void compileOpElementAsgnWithOr(Node node,
                                       BodyCompiler context,
                                       boolean expr)

compileOpElementAsgnWithAnd

public void compileOpElementAsgnWithAnd(Node node,
                                        BodyCompiler context,
                                        boolean expr)

compileOpElementAsgnWithMethod

public void compileOpElementAsgnWithMethod(Node node,
                                           BodyCompiler context,
                                           boolean expr)

compileOr

public void compileOr(Node node,
                      BodyCompiler context,
                      boolean expr)

compilePostExe

public void compilePostExe(Node node,
                           BodyCompiler context,
                           boolean expr)

compilePreExe

public void compilePreExe(Node node,
                          BodyCompiler context,
                          boolean expr)

compileRedo

public void compileRedo(Node node,
                        BodyCompiler context,
                        boolean expr)

compileRegexp

public void compileRegexp(Node node,
                          BodyCompiler context,
                          boolean expr)

compileRescue

public void compileRescue(Node node,
                          BodyCompiler context,
                          boolean expr)

compileRescueInternal

private void compileRescueInternal(Node node,
                                   BodyCompiler context,
                                   boolean light)

compileRescueBodyInternal

private void compileRescueBodyInternal(Node node,
                                       BodyCompiler context,
                                       boolean light)

compileRetry

public void compileRetry(Node node,
                         BodyCompiler context,
                         boolean expr)

compileReturn

public void compileReturn(Node node,
                          BodyCompiler context,
                          boolean expr)

compileRoot

public void compileRoot(Node node,
                        ScriptCompiler context,
                        ASTInspector inspector)

compileRoot

public void compileRoot(Node node,
                        ScriptCompiler context,
                        ASTInspector inspector,
                        boolean load,
                        boolean main)

compileSelf

public void compileSelf(Node node,
                        BodyCompiler context,
                        boolean expr)

compileSplat

public void compileSplat(Node node,
                         BodyCompiler context,
                         boolean expr)

splatCurrentValue

protected void splatCurrentValue(BodyCompiler context)

compileStr

public void compileStr(Node node,
                       BodyCompiler context,
                       boolean expr)

compileSuper

public void compileSuper(Node node,
                         BodyCompiler context,
                         boolean expr)

compileSValue

public void compileSValue(Node node,
                          BodyCompiler context,
                          boolean expr)

compileSymbol

public void compileSymbol(Node node,
                          BodyCompiler context,
                          boolean expr)

compileToAry

public void compileToAry(Node node,
                         BodyCompiler context,
                         boolean expr)

compileTrue

public void compileTrue(Node node,
                        BodyCompiler context,
                        boolean expr)

compileUndef

public void compileUndef(UndefNode undef,
                         BodyCompiler context,
                         boolean expr)

compileUntil

public void compileUntil(Node node,
                         BodyCompiler context,
                         boolean expr)

compileVAlias

public void compileVAlias(Node node,
                          BodyCompiler context,
                          boolean expr)

compileVCall

public void compileVCall(Node node,
                         BodyCompiler context,
                         boolean expr)

compileWhile

public void compileWhile(Node node,
                         BodyCompiler context,
                         boolean expr)

compileXStr

public void compileXStr(Node node,
                        BodyCompiler context,
                        boolean expr)

compileYield

public void compileYield(Node node,
                         BodyCompiler context,
                         boolean expr)

compileZArray

public void compileZArray(Node node,
                          BodyCompiler context,
                          boolean expr)

compileZSuper

public void compileZSuper(Node node,
                          BodyCompiler context,
                          boolean expr)

compileArgsCatArguments

public void compileArgsCatArguments(Node node,
                                    BodyCompiler context,
                                    boolean expr)

compileArgsPushArguments

public void compileArgsPushArguments(Node node,
                                     BodyCompiler context,
                                     boolean expr)

compileArrayArguments

public void compileArrayArguments(Node node,
                                  BodyCompiler context,
                                  boolean expr)

compileSplatArguments

public void compileSplatArguments(Node node,
                                  BodyCompiler context,
                                  boolean expr)

Class ASTCompiler

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

isAtRoot

Intrinsics

currentBodyNode

Constructor Detail

ASTCompiler

Method Detail

is1_9

compileBody

compile

compileArguments

getArgsCallback

compileAssignment

compileAlias

compileAnd

compileArray

isListAllLiterals

compileArgsCat

compileArgsPush

compileAttrAssign

compileAttrAssignAssignment

compileBackref

compileBegin

compileBignum

compileBlock

compileBreak

compileCall

getLiteralSend

compileCase

getHomogeneousSwitchType

compileWhen

getOptimizedCases

addConditionalForWhen

compileClass

compileSClass

compileClassVar

compileClassVarAsgn

compileClassVarAsgnAssignment

compileClassVarDecl

compileClassVarDeclAssignment

compileConstDecl

compileConstDeclAssignment

compileConst

compileColon2

compileColon3

compileGetDefinitionBase

compileDefined

compileGetArgumentDefinition

compileGetDefinition

compileDefinedAndOrDStrDRegexp

compileDefinedCall

compileDefinedDVar

compileDefinedBackref

compileDefinedNthref

compileDAsgn

compileDAsgnAssignment

compileDefn

compileDefs

compileArgs

compileDot

compileDRegexp

compileDNode

compileDStr

compileDSymbol

compileDVar

compileDXStr

compileEnsureNode

compileEvStr

compileFalse

compileFCall

getBlock

compileFixnum

compileFlip

becomeTrueOrFalse