ThreadContext

java.lang.Object
- org.jruby.runtime.ThreadContext

public final class ThreadContext
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`private BacktraceElement[]`	`backtrace`
`private int`	`backtraceIndex`
`private static int`	`CALL_POLL_COUNT` The number of calls after which to do a thread event poll
`int`	`callNumber`
`private int`	`catchIndex`
`private RubyContinuation.Continuation[]`	`catchStack`
`private int`	`currentMethodSerial`
`private RubyDateFormat`	`dateFormat` Deprecated.
`private RubyDateFormatter`	`dateFormatter`
`private static RubyContinuation.Continuation[]`	`EMPTY_CATCHTARGET_STACK`
`private boolean`	`eventHooksEnabled`
`private java.lang.ref.WeakReference<ThreadFiber>`	`fiber`
`private int`	`frameIndex`
`private Frame[]`	`frameStack`
`private static int`	`INITIAL_FRAMES_SIZE`
`private static int`	`INITIAL_SIZE`
`boolean`	`is19`
`private boolean`	`isProfiling`
`private boolean`	`isWithinTrace`
`(package private) CallType`	`lastCallType`
`(package private) IRubyObject`	`lastExitStatus`
`(package private) Visibility`	`lastVisibility`
`private static Logger`	`LOG`
`IRubyObject`	`nil`
`private static java.lang.ref.WeakReference<ThreadFiber>`	`NULL_FIBER_REF`
`private int`	`parentIndex`
`private RubyModule[]`	`parentStack`
`private ProfileCollection`	`profileCollection`
`private java.util.Set<RecursiveComparator.Pair>`	`recursiveSet`
`private ThreadFiber`	`rootFiber`
`private RubyThread`	`rootThread`
`Ruby`	`runtime`
`RuntimeCache`	`runtimeCache`
`private int`	`scopeIndex`
`private DynamicScope[]`	`scopeStack`
`java.security.SecureRandom`	`secureRandom`
`private RubyThread`	`thread`
`private static boolean`	`trySHA1PRNG`

Constructor Summary

Constructors
Modifier Constructor and Description

private ThreadContext(Ruby runtime)
Constructor for Context.

Constructors
Modifier	Constructor and Description
`private`	`ThreadContext(Ruby runtime)` Constructor for Context.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`callThreadPoll()`
`static void`	`callThreadPoll(ThreadContext context)`
`Frame[]`	`createBacktrace(int level, boolean nativeException)` Create an Array with backtrace information.
`BacktraceElement[]`	`createBacktrace2(int level, boolean nativeException)` Create an Array with backtrace information.
`IRubyObject`	`createCallerBacktrace(int level, java.lang.Integer length, java.lang.StackTraceElement[] stacktrace)` Create an Array with backtrace information for Kernel#caller
`IRubyObject`	`createCallerBacktrace(int level, java.lang.StackTraceElement[] stacktrace)` Create an Array with backtrace information for Kernel#caller
`IRubyObject`	`createCallerLocations(int level, java.lang.Integer length, java.lang.StackTraceElement[] stacktrace)` Create an array containing Thread::Backtrace::Location objects for the requested caller trace level and length.
`static java.lang.String`	`createRawBacktraceStringFromThrowable(java.lang.Throwable t)`
`private static java.lang.String`	`createRubyBacktraceString(java.lang.StackTraceElement element)`
`RubyStackTraceElement[]`	`createWarningBacktrace(Ruby runtime)` Create an Array with backtrace information for a built-in warning
`Binding`	`currentBinding()` Return a binding representing the current call's state
`Binding`	`currentBinding(IRubyObject self)` Return a binding representing the current call's state but with a specified self
`Binding`	`currentBinding(IRubyObject self, DynamicScope scope)` Return a binding representing the current call's state but with the specified scope and self.
`Binding`	`currentBinding(IRubyObject self, Visibility visibility)` Return a binding representing the current call's state but with the specified visibility and self.
`Binding`	`currentBinding(IRubyObject self, Visibility visibility, DynamicScope scope)` Return a binding representing the current call's state but with the specified visibility, scope, and self.
`private static void`	`expandBacktraceIfNecessary(ThreadContext context)`
`private void`	`expandCatchIfNecessary()`
`private void`	`expandFramesIfNecessary()`
`private void`	`expandParentsIfNecessary()`
`private void`	`expandScopesIfNecessary()`
`private static BacktraceElement[]`	`fillNewBacktrace(ThreadContext context, BacktraceElement[] newBacktrace, int newSize)`
`private Frame[]`	`fillNewFrameStack(Frame[] newFrameStack, int newSize)`
`protected void`	`finalize()`
`RubyStackTraceElement[]`	`gatherCallerBacktrace()`
`static RubyStackTraceElement[]`	`gatherRawBacktrace(Ruby runtime, java.lang.StackTraceElement[] stackTrace)`
`RubyContinuation.Continuation`	`getActiveCatch(java.lang.Object tag)` Find the active Continuation for the given tag.
`IRubyObject`	`getBackRef()` Get the value of the $~ (backref) "global".
`IRubyObject`	`getConstant(java.lang.String internedName)` Deprecated.
`boolean`	`getConstantDefined(java.lang.String internedName)` Deprecated.
`Frame`	`getCurrentFrame()`
`DynamicScope`	`getCurrentScope()`
`StaticScope`	`getCurrentStaticScope()`
`int`	`getCurrentTarget()`
`Visibility`	`getCurrentVisibility()`
`IRubyObject`	`getErrorInfo()`
`ThreadFiber`	`getFiber()`
`RubyThread`	`getFiberCurrentThread()`
`java.lang.String`	`getFile()`
`Block`	`getFrameBlock()`
`int`	`getFrameJumpTarget()`
`RubyModule`	`getFrameKlazz()`
`java.lang.String`	`getFrameName()`
`IRubyObject`	`getFrameSelf()`
`CallType`	`getLastCallType()`
`IRubyObject`	`getLastExitStatus()`
`IRubyObject`	`getLastLine()` Get the value of the $_ (lastline) "global".
`Visibility`	`getLastVisibility()`
`int`	`getLine()`
`Frame`	`getNextFrame()`
`Frame`	`getPreviousFrame()`
`RubyModule`	`getPreviousRubyClass()`
`DynamicScope`	`getPreviousScope()`
`Visibility`	`getPreviousVisibility()`
`ProfileCollection`	`getProfileCollection()` Get the profile collection for this thread (ThreadContext).
`java.util.Set<RecursiveComparator.Pair>`	`getRecursiveSet()`
`RubyModule`	`getRubyClass()`
`RubyDateFormat`	`getRubyDateFormat()` Deprecated.
`RubyDateFormatter`	`getRubyDateFormatter()`
`Ruby`	`getRuntime()` Retrieve the runtime associated with this context.
`RubyThread`	`getThread()`
`private RubyStackTraceElement[]`	`getTraceSubset(int level, java.lang.Integer length, java.lang.StackTraceElement[] stacktrace)`
`boolean`	`isEventHooksEnabled()`
`boolean`	`isJumpTargetAlive(int target, int skipFrames)` Search the frame stack for the given JumpTarget.
`boolean`	`isProfiling()`
`boolean`	`isWithinTrace()` Is this thread actively tracing at this moment.
`static ThreadContext`	`newContext(Ruby runtime)`
`void`	`pollThreadEvents()`
`static void`	`popBacktrace(ThreadContext context)`
`void`	`popCatch()`
`void`	`popFrame()`
`private void`	`popFrameReal(Frame oldFrame)`
`RubyModule`	`popRubyClass()`
`void`	`popScope()`
`void`	`postBsfApply()`
`void`	`postClassEval()`
`void`	`postCompiledClass()`
`void`	`postEvalScriptlet()`
`void`	`postEvalWithBinding(Binding binding, Frame lastFrame)`
`void`	`postExecuteUnder()`
`void`	`postExtensionLoad()`
`void`	`postMethodBacktraceAndScope()`
`void`	`postMethodBacktraceDummyScope()`
`void`	`postMethodBacktraceOnly()`
`void`	`postMethodFrameAndScope()`
`void`	`postMethodFrameOnly()`
`void`	`postMethodScopeOnly()`
`void`	`postMproc()`
`void`	`postNodeEval()`
`void`	`postScopedBody()`
`void`	`postScopeNode()`
`void`	`postTrace()`
`void`	`postYield(Binding binding, Frame lastFrame)`
`void`	`postYieldLight(Binding binding, Frame lastFrame)`
`void`	`postYieldNoScope(Frame lastFrame)`
`void`	`preAdoptThread()`
`void`	`preBsfApply(java.lang.String[] names)`
`void`	`preClassEval(StaticScope staticScope, RubyModule type)`
`void`	`preCompiledClass(RubyModule type, StaticScope staticScope)`
`void`	`preCompiledClassDummyScope(RubyModule type, StaticScope staticScope)`
`void`	`preEvalScriptlet(DynamicScope scope)`
`Frame`	`preEvalWithBinding(Binding binding)`
`void`	`preExecuteUnder(IRubyObject self, RubyModule executeUnderClass, Block block)`
`void`	`preExtensionLoad(IRubyObject self)`
`Frame`	`preForBlock(Binding binding, RubyModule klass)`
`void`	`preMethodBacktraceAndScope(java.lang.String name, RubyModule clazz, StaticScope staticScope)`
`void`	`preMethodBacktraceDummyScope(RubyModule clazz, java.lang.String name, StaticScope staticScope)`
`void`	`preMethodBacktraceOnly(java.lang.String name)`
`void`	`preMethodFrameAndClass(RubyModule implClass, java.lang.String name, IRubyObject self, Block block, StaticScope staticScope)`
`void`	`preMethodFrameAndDummyScope(RubyModule clazz, java.lang.String name, IRubyObject self, Block block, StaticScope staticScope)`
`void`	`preMethodFrameAndScope(RubyModule clazz, java.lang.String name, IRubyObject self, Block block, StaticScope staticScope)`
`void`	`preMethodFrameOnly(RubyModule clazz, java.lang.String name, IRubyObject self, Block block)`
`void`	`preMethodNoFrameAndDummyScope(RubyModule clazz, StaticScope staticScope)`
`void`	`preMethodScopeOnly(RubyModule clazz, StaticScope staticScope)`
`void`	`preMproc()`
`void`	`preNodeEval(RubyModule rubyClass, IRubyObject self)`
`void`	`preNodeEval(RubyModule rubyClass, IRubyObject self, java.lang.String name)`
`void`	`prepareTopLevel(RubyClass objectClass, IRubyObject topSelf)`
`void`	`preScopedBody(DynamicScope scope)`
`void`	`preScopeNode(StaticScope staticScope)`
`void`	`preTrace()`
`Binding`	`previousBinding()` Deprecated.
`Binding`	`previousBinding(IRubyObject self)` Deprecated.
`Frame`	`preYieldLightBlock(Binding binding, DynamicScope emptyScope, RubyModule klass)`
`Frame`	`preYieldNoScope(Binding binding, RubyModule klass)`
`Frame`	`preYieldSpecificBlock(Binding binding, StaticScope scope, RubyModule klass)`
`void`	`printScope()`
`int`	`profileEnter(int nextMethod)`
`int`	`profileEnter(java.lang.String name, DynamicMethod nextMethod)`
`int`	`profileExit(int nextMethod, long startTime)`
`static void`	`pushBacktrace(ThreadContext context, java.lang.String method, ISourcePosition position)`
`static void`	`pushBacktrace(ThreadContext context, java.lang.String method, java.lang.String file, int line)`
`private void`	`pushCallFrame(RubyModule clazz, java.lang.String name, IRubyObject self, Block block)`
`void`	`pushCatch(RubyContinuation.Continuation catchTarget)`
`private void`	`pushEvalFrame(IRubyObject self)`
`void`	`pushFrame()`
`private Frame`	`pushFrame(Frame frame)`
`private void`	`pushFrameCopy()`
`private Frame`	`pushFrameForBlock(Binding binding)`
`private Frame`	`pushFrameForEval(Binding binding)`
`void`	`pushRubyClass(RubyModule currentModule)`
`void`	`pushScope(DynamicScope scope)`
`void`	`renderCurrentBacktrace(java.lang.StringBuilder sb)` Render the current backtrace as a string to the given StringBuilder.
`JumpException.ReturnJump`	`returnJump(IRubyObject value)`
`private static int`	`safeLength(int level, java.lang.Integer length, RubyStackTraceElement[] trace)`
`boolean`	`scopeExistsOnCallStack(StaticScope s)` Check if a static scope is present on the call stack.
`IRubyObject`	`setBackRef(IRubyObject match)` Set the $~ (backref) "global" to the given value.
`IRubyObject`	`setConstantInCurrent(java.lang.String internedName, IRubyObject result)` Deprecated.
`IRubyObject`	`setConstantInModule(java.lang.String internedName, IRubyObject target, IRubyObject result)` Deprecated.
`IRubyObject`	`setConstantInObject(java.lang.String internedName, IRubyObject result)` Deprecated.
`void`	`setCurrentVisibility(Visibility visibility)`
`IRubyObject`	`setErrorInfo(IRubyObject errorInfo)`
`void`	`setEventHooksEnabled(boolean flag)`
`void`	`setFiber(ThreadFiber fiber)`
`void`	`setFile(java.lang.String file)` Deprecated.
`void`	`setFileAndLine(ISourcePosition position)`
`void`	`setFileAndLine(java.lang.String file, int line)`
`void`	`setLastCallStatus(CallType callType)` Returns the lastCallStatus.
`void`	`setLastCallStatusAndVisibility(CallType callType, Visibility visibility)`
`void`	`setLastExitStatus(IRubyObject lastExitStatus)`
`IRubyObject`	`setLastLine(IRubyObject last)` Set the $_ (lastlne) "global" to the given value.
`void`	`setLastVisibility(Visibility visibility)`
`void`	`setLine(int line)`
`void`	`setRecursiveSet(java.util.Set<RecursiveComparator.Pair> recursiveSet)`
`void`	`setRootFiber(ThreadFiber rootFiber)`
`void`	`setRootThread(RubyThread rootThread)`
`void`	`setThread(RubyThread thread)`
`void`	`setWithinTrace(boolean isWithinTrace)` Set whether we are actively tracing or not on this thread.
`void`	`startProfiling()`
`void`	`stopProfiling()`
`void`	`trace(RubyEvent event, java.lang.String name, RubyModule implClass)`
`void`	`trace(RubyEvent event, java.lang.String name, RubyModule implClass, java.lang.String file, int line)`

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

Field Detail

LOG
```
private static final Logger LOG
```

INITIAL_SIZE
```
private static final int INITIAL_SIZE
```
See Also:

Constant Field Values

INITIAL_FRAMES_SIZE
```
private static final int INITIAL_FRAMES_SIZE
```
See Also:

Constant Field Values

CALL_POLL_COUNT
```
private static final int CALL_POLL_COUNT
```
The number of calls after which to do a thread event poll

See Also:

Constant Field Values

runtime
```
public final Ruby runtime
```

nil
```
public final IRubyObject nil
```

runtimeCache
```
public final RuntimeCache runtimeCache
```

is19
```
public final boolean is19
```

isWithinTrace
```
private boolean isWithinTrace
```

thread
```
private RubyThread thread
```

rootThread
```
private RubyThread rootThread
```

NULL_FIBER_REF

private static final java.lang.ref.WeakReference<ThreadFiber> NULL_FIBER_REF

fiber

private java.lang.ref.WeakReference<ThreadFiber> fiber

rootFiber
```
private ThreadFiber rootFiber
```

dateFormatter

private RubyDateFormatter dateFormatter

parentStack
```
private RubyModule[] parentStack
```

parentIndex
```
private int parentIndex
```

frameStack
```
private Frame[] frameStack
```

frameIndex
```
private int frameIndex
```

backtrace
```
private BacktraceElement[] backtrace
```

backtraceIndex
```
private int backtraceIndex
```

scopeStack
```
private DynamicScope[] scopeStack
```

scopeIndex
```
private int scopeIndex
```

EMPTY_CATCHTARGET_STACK

private static final RubyContinuation.Continuation[] EMPTY_CATCHTARGET_STACK

catchStack

private RubyContinuation.Continuation[] catchStack

catchIndex
```
private int catchIndex
```

isProfiling
```
private boolean isProfiling
```

profileCollection

private ProfileCollection profileCollection

eventHooksEnabled
```
private boolean eventHooksEnabled
```

lastCallType
```
CallType lastCallType
```

lastVisibility
```
Visibility lastVisibility
```

lastExitStatus
```
IRubyObject lastExitStatus
```

secureRandom

public final java.security.SecureRandom secureRandom

trySHA1PRNG
```
private static boolean trySHA1PRNG
```

callNumber
```
public int callNumber
```

currentMethodSerial
```
private int currentMethodSerial
```

recursiveSet

private java.util.Set<RecursiveComparator.Pair> recursiveSet

dateFormat

@Deprecated
private RubyDateFormat dateFormat

Deprecated.

Constructor Detail
- ThreadContext
```
private ThreadContext(Ruby runtime)
```
  Constructor for Context.

Method Detail

newContext

public static ThreadContext newContext(Ruby runtime)

finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
Overrides:

finalize in class java.lang.Object

Throws:

java.lang.Throwable

getRuntime
```
public final Ruby getRuntime()
```
Retrieve the runtime associated with this context. Note that there's no reason to call this method rather than accessing the runtime field directly.

Returns:

the runtime associated with this context

See Also:

runtime

getErrorInfo
```
public IRubyObject getErrorInfo()
```

setErrorInfo

public IRubyObject setErrorInfo(IRubyObject errorInfo)

returnJump

public JumpException.ReturnJump returnJump(IRubyObject value)

setLastCallStatus

public void setLastCallStatus(CallType callType)

Returns the lastCallStatus.

getLastCallType
```
public CallType getLastCallType()
```

setLastVisibility

public void setLastVisibility(Visibility visibility)

getLastVisibility
```
public Visibility getLastVisibility()
```

setLastCallStatusAndVisibility

public void setLastCallStatusAndVisibility(CallType callType,
                                           Visibility visibility)

getLastExitStatus

public IRubyObject getLastExitStatus()

setLastExitStatus

public void setLastExitStatus(IRubyObject lastExitStatus)

printScope
```
public void printScope()
```

getCurrentScope
```
public DynamicScope getCurrentScope()
```

getCurrentStaticScope

public StaticScope getCurrentStaticScope()

getPreviousScope

public DynamicScope getPreviousScope()

expandFramesIfNecessary

private void expandFramesIfNecessary()

fillNewFrameStack

private Frame[] fillNewFrameStack(Frame[] newFrameStack,
                                  int newSize)

expandParentsIfNecessary

private void expandParentsIfNecessary()

pushScope

public void pushScope(DynamicScope scope)

popScope
```
public void popScope()
```

expandScopesIfNecessary

private void expandScopesIfNecessary()

getThread
```
public RubyThread getThread()
```

getFiberCurrentThread

public RubyThread getFiberCurrentThread()

getRubyDateFormatter

public RubyDateFormatter getRubyDateFormatter()

setThread

public void setThread(RubyThread thread)

getFiber
```
public ThreadFiber getFiber()
```

setFiber

public void setFiber(ThreadFiber fiber)

setRootFiber

public void setRootFiber(ThreadFiber rootFiber)

setRootThread

public void setRootThread(RubyThread rootThread)

expandCatchIfNecessary
```
private void expandCatchIfNecessary()
```

pushCatch

public void pushCatch(RubyContinuation.Continuation catchTarget)

popCatch
```
public void popCatch()
```

getActiveCatch
```
public RubyContinuation.Continuation getActiveCatch(java.lang.Object tag)
```
Find the active Continuation for the given tag. Must be called with an interned string.

Parameters:

tag - The interned string to search for

Returns:

The continuation associated with this tag

pushFrameCopy
```
private void pushFrameCopy()
```

pushFrame
```
private Frame pushFrame(Frame frame)
```

pushCallFrame

private void pushCallFrame(RubyModule clazz,
                           java.lang.String name,
                           IRubyObject self,
                           Block block)

pushEvalFrame

private void pushEvalFrame(IRubyObject self)

pushFrame
```
public void pushFrame()
```

popFrame
```
public void popFrame()
```

popFrameReal

private void popFrameReal(Frame oldFrame)

getCurrentFrame
```
public Frame getCurrentFrame()
```

getNextFrame
```
public Frame getNextFrame()
```

getPreviousFrame
```
public Frame getPreviousFrame()
```

setBackRef
```
public IRubyObject setBackRef(IRubyObject match)
```
Set the $~ (backref) "global" to the given value.

Parameters:

match - the value to set

Returns:

the value passed in

getBackRef
```
public IRubyObject getBackRef()
```
Get the value of the $~ (backref) "global".

Returns:

the value of $~

setLastLine
```
public IRubyObject setLastLine(IRubyObject last)
```
Set the $_ (lastlne) "global" to the given value.

Parameters:

last - the value to set

Returns:

the value passed in

getLastLine
```
public IRubyObject getLastLine()
```
Get the value of the $_ (lastline) "global".

Returns:

the value of $_

expandBacktraceIfNecessary

private static void expandBacktraceIfNecessary(ThreadContext context)

fillNewBacktrace

private static BacktraceElement[] fillNewBacktrace(ThreadContext context,
                                                   BacktraceElement[] newBacktrace,
                                                   int newSize)

pushBacktrace

public static void pushBacktrace(ThreadContext context,
                                 java.lang.String method,
                                 ISourcePosition position)

pushBacktrace

public static void pushBacktrace(ThreadContext context,
                                 java.lang.String method,
                                 java.lang.String file,
                                 int line)

popBacktrace

public static void popBacktrace(ThreadContext context)

isJumpTargetAlive
```
public boolean isJumpTargetAlive(int target,
                                 int skipFrames)
```
Search the frame stack for the given JumpTarget. Return true if it is found and false otherwise. Skip the given number of frames before beginning the search.

Parameters:

target - The JumpTarget to search for

skipFrames - The number of frames to skip before searching

Returns:

scopeExistsOnCallStack
```
public boolean scopeExistsOnCallStack(StaticScope s)
```
Check if a static scope is present on the call stack. This is the IR equivalent of isJumpTargetAlive

Parameters:

s - the static scope to look for

Returns:

true if it exists false if not

getFrameName

public java.lang.String getFrameName()

getFrameSelf
```
public IRubyObject getFrameSelf()
```

getFrameJumpTarget
```
public int getFrameJumpTarget()
```

getFrameKlazz
```
public RubyModule getFrameKlazz()
```

getFrameBlock
```
public Block getFrameBlock()
```

getFile
```
public java.lang.String getFile()
```

getLine
```
public int getLine()
```

setLine
```
public void setLine(int line)
```

setFileAndLine

public void setFileAndLine(java.lang.String file,
                           int line)

setFileAndLine

public void setFileAndLine(ISourcePosition position)

getCurrentVisibility

public Visibility getCurrentVisibility()

getPreviousVisibility

public Visibility getPreviousVisibility()

setCurrentVisibility

public void setCurrentVisibility(Visibility visibility)

pollThreadEvents
```
public void pollThreadEvents()
```

getCurrentTarget
```
public int getCurrentTarget()
```

callThreadPoll
```
public void callThreadPoll()
```

callThreadPoll

public static void callThreadPoll(ThreadContext context)

trace

public void trace(RubyEvent event,
                  java.lang.String name,
                  RubyModule implClass)

trace

public void trace(RubyEvent event,
                  java.lang.String name,
                  RubyModule implClass,
                  java.lang.String file,
                  int line)

pushRubyClass

public void pushRubyClass(RubyModule currentModule)

popRubyClass
```
public RubyModule popRubyClass()
```

getRubyClass
```
public RubyModule getRubyClass()
```

getPreviousRubyClass

public RubyModule getPreviousRubyClass()

getConstantDefined

@Deprecated
public boolean getConstantDefined(java.lang.String internedName)

Deprecated.

getConstant
```
@Deprecated
public IRubyObject getConstant(java.lang.String internedName)
```
Deprecated.

Used by the evaluator and the compiler to look up a constant by name

setConstantInCurrent

@Deprecated
public IRubyObject setConstantInCurrent(java.lang.String internedName,
                                                    IRubyObject result)

Deprecated.

Used by the evaluator and the compiler to set a constant by name This is for a null const decl

setConstantInModule

@Deprecated
public IRubyObject setConstantInModule(java.lang.String internedName,
                                                   IRubyObject target,
                                                   IRubyObject result)

Deprecated.

Used by the evaluator and the compiler to set a constant by name. This is for a Colon2 const decl

setConstantInObject

@Deprecated
public IRubyObject setConstantInObject(java.lang.String internedName,
                                                   IRubyObject result)

Deprecated.

Used by the evaluator and the compiler to set a constant by name This is for a Colon2 const decl

renderCurrentBacktrace
```
public void renderCurrentBacktrace(java.lang.StringBuilder sb)
```
Render the current backtrace as a string to the given StringBuilder. This will honor the currently-configured backtrace format and content.

Parameters:

sb - the StringBuilder to which to render the backtrace

createCallerBacktrace

public IRubyObject createCallerBacktrace(int level,
                                         java.lang.StackTraceElement[] stacktrace)

Create an Array with backtrace information for Kernel#caller

Parameters:: runtime -; level -
Returns:: an Array with the backtrace

createCallerBacktrace

public IRubyObject createCallerBacktrace(int level,
                                         java.lang.Integer length,
                                         java.lang.StackTraceElement[] stacktrace)

Create an Array with backtrace information for Kernel#caller

Parameters:: runtime -; level -; length -
Returns:: an Array with the backtrace

createCallerLocations
```
public IRubyObject createCallerLocations(int level,
                                         java.lang.Integer length,
                                         java.lang.StackTraceElement[] stacktrace)
```
Create an array containing Thread::Backtrace::Location objects for the requested caller trace level and length.

Parameters:

level - the level at which the trace should start

length - the length of the trace

Returns:

an Array with the backtrace locations

getTraceSubset

private RubyStackTraceElement[] getTraceSubset(int level,
                                               java.lang.Integer length,
                                               java.lang.StackTraceElement[] stacktrace)

safeLength

private static int safeLength(int level,
                              java.lang.Integer length,
                              RubyStackTraceElement[] trace)

createWarningBacktrace
```
public RubyStackTraceElement[] createWarningBacktrace(Ruby runtime)
```
Create an Array with backtrace information for a built-in warning

Parameters:

runtime -

Returns:

an Array with the backtrace

gatherCallerBacktrace

public RubyStackTraceElement[] gatherCallerBacktrace()

createBacktrace
```
public Frame[] createBacktrace(int level,
                               boolean nativeException)
```
Create an Array with backtrace information.

Parameters:

level -

nativeException -

Returns:

an Array with the backtrace

isEventHooksEnabled
```
public boolean isEventHooksEnabled()
```

setEventHooksEnabled

public void setEventHooksEnabled(boolean flag)

createBacktrace2

public BacktraceElement[] createBacktrace2(int level,
                                           boolean nativeException)

Create an Array with backtrace information.

Parameters:: level -; nativeException -
Returns:: an Array with the backtrace

createRubyBacktraceString

private static java.lang.String createRubyBacktraceString(java.lang.StackTraceElement element)

createRawBacktraceStringFromThrowable

public static java.lang.String createRawBacktraceStringFromThrowable(java.lang.Throwable t)

gatherRawBacktrace

public static RubyStackTraceElement[] gatherRawBacktrace(Ruby runtime,
                                                         java.lang.StackTraceElement[] stackTrace)

pushFrameForBlock

private Frame pushFrameForBlock(Binding binding)

pushFrameForEval

private Frame pushFrameForEval(Binding binding)

preAdoptThread
```
public void preAdoptThread()
```

preExtensionLoad

public void preExtensionLoad(IRubyObject self)

postExtensionLoad
```
public void postExtensionLoad()
```

preCompiledClass

public void preCompiledClass(RubyModule type,
                             StaticScope staticScope)

preCompiledClassDummyScope

public void preCompiledClassDummyScope(RubyModule type,
                                       StaticScope staticScope)

postCompiledClass
```
public void postCompiledClass()
```

preScopeNode

public void preScopeNode(StaticScope staticScope)

postScopeNode
```
public void postScopeNode()
```

preClassEval

public void preClassEval(StaticScope staticScope,
                         RubyModule type)

postClassEval
```
public void postClassEval()
```

preBsfApply

public void preBsfApply(java.lang.String[] names)

postBsfApply
```
public void postBsfApply()
```

preMethodFrameAndClass

public void preMethodFrameAndClass(RubyModule implClass,
                                   java.lang.String name,
                                   IRubyObject self,
                                   Block block,
                                   StaticScope staticScope)

preMethodFrameAndScope

public void preMethodFrameAndScope(RubyModule clazz,
                                   java.lang.String name,
                                   IRubyObject self,
                                   Block block,
                                   StaticScope staticScope)

preMethodFrameAndDummyScope

public void preMethodFrameAndDummyScope(RubyModule clazz,
                                        java.lang.String name,
                                        IRubyObject self,
                                        Block block,
                                        StaticScope staticScope)

preMethodNoFrameAndDummyScope

public void preMethodNoFrameAndDummyScope(RubyModule clazz,
                                          StaticScope staticScope)

postMethodFrameAndScope
```
public void postMethodFrameAndScope()
```

preMethodFrameOnly

public void preMethodFrameOnly(RubyModule clazz,
                               java.lang.String name,
                               IRubyObject self,
                               Block block)

postMethodFrameOnly
```
public void postMethodFrameOnly()
```

preMethodScopeOnly

public void preMethodScopeOnly(RubyModule clazz,
                               StaticScope staticScope)

postMethodScopeOnly
```
public void postMethodScopeOnly()
```

preMethodBacktraceAndScope

public void preMethodBacktraceAndScope(java.lang.String name,
                                       RubyModule clazz,
                                       StaticScope staticScope)

postMethodBacktraceAndScope

public void postMethodBacktraceAndScope()

preMethodBacktraceOnly

public void preMethodBacktraceOnly(java.lang.String name)

preMethodBacktraceDummyScope

public void preMethodBacktraceDummyScope(RubyModule clazz,
                                         java.lang.String name,
                                         StaticScope staticScope)

postMethodBacktraceOnly
```
public void postMethodBacktraceOnly()
```

postMethodBacktraceDummyScope

public void postMethodBacktraceDummyScope()

prepareTopLevel

public void prepareTopLevel(RubyClass objectClass,
                            IRubyObject topSelf)

preNodeEval

public void preNodeEval(RubyModule rubyClass,
                        IRubyObject self,
                        java.lang.String name)

preNodeEval

public void preNodeEval(RubyModule rubyClass,
                        IRubyObject self)

postNodeEval
```
public void postNodeEval()
```

preExecuteUnder

public void preExecuteUnder(IRubyObject self,
                            RubyModule executeUnderClass,
                            Block block)

postExecuteUnder
```
public void postExecuteUnder()
```

preMproc
```
public void preMproc()
```

postMproc
```
public void postMproc()
```

preTrace
```
public void preTrace()
```

postTrace
```
public void postTrace()
```

preForBlock

public Frame preForBlock(Binding binding,
                         RubyModule klass)

preYieldSpecificBlock

public Frame preYieldSpecificBlock(Binding binding,
                                   StaticScope scope,
                                   RubyModule klass)

preYieldLightBlock

public Frame preYieldLightBlock(Binding binding,
                                DynamicScope emptyScope,
                                RubyModule klass)

preYieldNoScope

public Frame preYieldNoScope(Binding binding,
                             RubyModule klass)

preEvalScriptlet

public void preEvalScriptlet(DynamicScope scope)

postEvalScriptlet
```
public void postEvalScriptlet()
```

preEvalWithBinding

public Frame preEvalWithBinding(Binding binding)

postEvalWithBinding

public void postEvalWithBinding(Binding binding,
                                Frame lastFrame)

postYield

public void postYield(Binding binding,
                      Frame lastFrame)

postYieldLight

public void postYieldLight(Binding binding,
                           Frame lastFrame)

postYieldNoScope

public void postYieldNoScope(Frame lastFrame)

preScopedBody

public void preScopedBody(DynamicScope scope)

postScopedBody
```
public void postScopedBody()
```

isWithinTrace
```
public boolean isWithinTrace()
```
Is this thread actively tracing at this moment.

Returns:

true if so

See Also:

Ruby.callEventHooks(ThreadContext, RubyEvent, String, int, String, org.jruby.runtime.builtin.IRubyObject)

setWithinTrace
```
public void setWithinTrace(boolean isWithinTrace)
```
Set whether we are actively tracing or not on this thread.

Parameters:

isWithinTrace - true is so

See Also:

Ruby.callEventHooks(ThreadContext, RubyEvent, String, int, String, org.jruby.runtime.builtin.IRubyObject)

currentBinding
```
public Binding currentBinding()
```
Return a binding representing the current call's state

Returns:

the current binding

currentBinding
```
public Binding currentBinding(IRubyObject self)
```
Return a binding representing the current call's state but with a specified self

Parameters:

self - the self object to use

Returns:

the current binding, using the specified self

currentBinding
```
public Binding currentBinding(IRubyObject self,
                              Visibility visibility)
```
Return a binding representing the current call's state but with the specified visibility and self.

Parameters:

self - the self object to use

visibility - the visibility to use

Returns:

the current binding using the specified self and visibility

currentBinding
```
public Binding currentBinding(IRubyObject self,
                              DynamicScope scope)
```
Return a binding representing the current call's state but with the specified scope and self.

Parameters:

self - the self object to use

scope - the scope to use

Returns:

the current binding using the specified self and scope

currentBinding
```
public Binding currentBinding(IRubyObject self,
                              Visibility visibility,
                              DynamicScope scope)
```
Return a binding representing the current call's state but with the specified visibility, scope, and self. For shared-scope binding consumers like for loops.

Parameters:

self - the self object to use

visibility - the visibility to use

scope - the scope to use

Returns:

the current binding using the specified self, scope, and visibility

previousBinding
```
@Deprecated
public Binding previousBinding()
```
Deprecated.

Return a binding representing the previous call's state

Returns:

the current binding

previousBinding
```
@Deprecated
public Binding previousBinding(IRubyObject self)
```
Deprecated.

Return a binding representing the previous call's state but with a specified self

Parameters:

self - the self object to use

Returns:

the current binding, using the specified self

getProfileCollection
```
public ProfileCollection getProfileCollection()
```
Get the profile collection for this thread (ThreadContext).

Returns:

the thread's profile collection

startProfiling
```
public void startProfiling()
```

stopProfiling
```
public void stopProfiling()
```

isProfiling
```
public boolean isProfiling()
```

profileEnter

public int profileEnter(int nextMethod)

profileEnter

public int profileEnter(java.lang.String name,
                        DynamicMethod nextMethod)

profileExit

public int profileExit(int nextMethod,
                       long startTime)

getRecursiveSet

public java.util.Set<RecursiveComparator.Pair> getRecursiveSet()

setRecursiveSet

public void setRecursiveSet(java.util.Set<RecursiveComparator.Pair> recursiveSet)

setFile

@Deprecated
public void setFile(java.lang.String file)

Deprecated.

getRubyDateFormat

@Deprecated
public RubyDateFormat getRubyDateFormat()

Deprecated.

Class ThreadContext

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

INITIAL_SIZE

INITIAL_FRAMES_SIZE

CALL_POLL_COUNT

runtime

nil

runtimeCache

is19

isWithinTrace

thread

rootThread

NULL_FIBER_REF

fiber

rootFiber

dateFormatter

parentStack

parentIndex

frameStack

frameIndex

backtrace

backtraceIndex

scopeStack

scopeIndex

EMPTY_CATCHTARGET_STACK

catchStack

catchIndex

isProfiling

profileCollection

eventHooksEnabled

lastCallType

lastVisibility

lastExitStatus

secureRandom

trySHA1PRNG

callNumber

currentMethodSerial

recursiveSet

dateFormat

Constructor Detail

ThreadContext

Method Detail

newContext

finalize

getRuntime

getErrorInfo

setErrorInfo

returnJump

setLastCallStatus

getLastCallType

setLastVisibility

getLastVisibility

setLastCallStatusAndVisibility

getLastExitStatus

setLastExitStatus

printScope

getCurrentScope

getCurrentStaticScope

getPreviousScope

expandFramesIfNecessary

fillNewFrameStack

expandParentsIfNecessary

pushScope

popScope

expandScopesIfNecessary

getThread

getFiberCurrentThread

getRubyDateFormatter

setThread

getFiber

setFiber

setRootFiber

setRootThread

expandCatchIfNecessary

pushCatch