#include <RexxActivation.hpp>

Inheritance diagram for RexxActivation:

Public Member Functions
void *	operator new (size_t)

void *	operator new (size_t size, void *ptr)

void	operator delete (void *)

void	operator delete (void , void )

	RexxActivation (RESTORETYPE restoreType)

	RexxActivation ()

	RexxActivation (RexxActivity _activity, RexxActivation _parent, RexxMethod _method, RexxCode _code)

	RexxActivation (RexxActivity _activity, RexxActivation _parent, RoutineClass _routine, RexxCode _code, RexxString calltype, RexxString env, int context)

	RexxActivation (RexxActivity _activity, RexxActivation _parent, RexxCode *_code, int context)

void	live (size_t)

void	liveGeneral (int reason)

RexxObject *	dispatch ()

size_t	digits ()

size_t	fuzz ()

bool	form ()

bool	propagateNumericSettings ()

bool	enableCommands ()

bool	enableMacrospace ()

void	setDigits (size_t)

void	setFuzz (size_t)

void	setForm (bool)

void	enableCommands (bool)

void	enableMacrospace (bool)

void	setDigits ()

void	setFuzz ()

void	setForm ()

void	propagateNumericSettings (bool)

bool	trap (RexxString , RexxDirectory )

void	setObjNotify (RexxMessage *)

void	termination ()

void	guardOff ()

bool	isInterpret ()

bool	isInternalCall ()

bool	isMethod ()

bool	isRoutine ()

bool	isProgram ()

bool	isTopLevelCall ()

bool	isProgramLevelCall ()

bool	isInternalLevelCall ()

bool	isProgramOrMethod ()

bool	isMethodOrRoutine ()

RexxObject *	run (RexxObject _receiver, RexxString msgname, RexxArray _arguments, RexxObject _arglist, size_t _argcount, size_t _named_argcount, RexxInstruction start, ProtectedObject &resultObj)

RexxObject *	run (RexxArray _arguments, RexxObject *_arglist, size_t _argcount, size_t _named_argcount, ProtectedObject &_result)

void	reply (RexxObject *)

RexxObject *	forward (RexxObject , RexxString , RexxObject , RexxObject *, size_t, size_t, bool)

void	returnFrom (RexxObject *result)

void	exitFrom (RexxObject *)

void	procedureExpose (RexxVariableBase **variables, size_t count)

void	expose (RexxVariableBase **variables, size_t count)

void	setTrace (size_t, size_t)

void	setTrace (RexxString *, bool externalTrace=false, size_t depth=0)

void	raise (RexxString , RexxObject , RexxString , RexxObject , RexxObject , RexxDirectory )

void	toggleAddress ()

void	guardOn ()

void	raiseExit (RexxString , RexxObject , RexxString , RexxObject , RexxObject , RexxDirectory )

RexxActivation *	senderActivation ()

RexxActivation *	external ()

void	interpret (RexxString *)

void	signalTo (RexxInstruction *)

void	guardWait ()

void	debugSkip (wholenumber_t, bool)

RexxString *	traceSetting ()

void	iterate (RexxString *)

void	leaveLoop (RexxString *)

void	trapOn (RexxString , RexxInstructionCallBase )

void	trapOff (RexxString *)

void	setAddress (RexxString *)

void	signalValue (RexxString *)

RexxString *	trapState (RexxString *)

void	trapDelay (RexxString *)

void	trapUndelay (RexxString *)

bool	callExternalRexx (RexxString , RexxObject , size_t, size_t, RexxString , ProtectedObject &)

RexxObject *	externalCall (RexxString , RexxObject , size_t, size_t, RexxString , ProtectedObject &)

RexxObject *	internalCall (RexxString , RexxInstruction , RexxObject **, size_t, size_t, ProtectedObject &)

RexxObject *	internalCallTrap (RexxString , RexxInstruction , RexxDirectory *, ProtectedObject &)

bool	callMacroSpaceFunction (RexxString , RexxObject , size_t, size_t, RexxString , int, ProtectedObject &)

RexxString *	resolveProgramName (RexxString *name)

RexxClass *	findClass (RexxString *name)

RexxObject *	resolveDotVariable (RexxString *name)

void	command (RexxString , RexxString )

int64_t	getElapsed ()

RexxDateTime	getTime ()

RexxInteger *	random (RexxInteger , RexxInteger , RexxInteger *)

size_t	currentLine ()

void	traceValue (RexxObject *, int)

void	traceCompoundValue (int prefix, RexxString stemName, RexxObject tails, size_t tailCount, RexxCompoundTail tail)

void	traceCompoundValue (int prefix, RexxString stem, RexxObject tails, size_t tailCount, const char marker, RexxObject *value, bool quoteValue=true)

void	traceTaggedValue (int prefix, const char tagPrefix, bool quoteTag, RexxString tag, const char marker, RexxObject value, bool quoteValue=true)

void	traceOperatorValue (int prefix, const char tag, RexxObject value)

void	traceSourceString ()

void	traceClause (RexxInstruction *, int)

void	traceEntry ()

void	resetElapsed ()

RexxString *	formatTrace (RexxInstruction , RexxSource )

RexxString *	getTraceBack ()

RexxDirectory *	local ()

RexxString *	formatSourcelessTraceLine (RexxString *packageName)

RexxArray *	getStackFrames (bool skipFirst)

void	implicitExit ()

void	unwindTrap (RexxActivation *)

RexxString *	sourceString ()

void	addLocalRoutine (RexxString name, RexxMethod method)

RexxDirectory *	getPublicRoutines ()

void	debugInterpret (RexxString *)

bool	debugPause (RexxInstruction *instr=OREF_NULL)

void	processClauseBoundary ()

bool	halt (RexxString *)

void	externalTraceOn ()

void	externalTraceOff ()

void	yield ()

void	propagateExit (RexxObject *)

void	setDefaultAddress (RexxString *)

bool	internalMethod ()

PackageClass *	loadRequires (RexxString , RexxInstruction )

void	loadLibrary (RexxString target, RexxInstruction instruction)

RexxObject *	rexxVariable (RexxString *)

void	pushEnvironment (RexxObject *)

RexxObject *	popEnvironment ()

void	processTraps ()

void	mergeTraps (RexxQueue , RexxQueue )

uint64_t	getRandomSeed (RexxInteger *)

void	adjustRandomSeed ()

RexxVariableDictionary *	getObjectVariables ()

RexxDirectory *	getLabels ()

RexxString *	getProgramName ()

RexxObject *	popControl ()

void	pushControl (RexxObject *)

void	closeStreams ()

void	checkTrapTable ()

RexxObject *	resolveStream (RexxString name, bool input, RexxString fullName, bool added)

RexxDirectory *	getStreams ()

RexxObject *	novalueHandler (RexxString *)

RexxVariableBase *	retriever (RexxString *)

RexxVariableBase *	directRetriever (RexxString *)

RexxObject *	handleNovalueEvent (RexxString name, RexxObject defaultValue, RexxVariable *variable)

RexxSource *	getSourceObject ()

RexxSource *	getEffectiveSourceObject ()

PackageClass *	getPackage ()

RexxObject *	getLocalEnvironment (RexxString *name)

RexxDirectory *	getThreadLocal ()

void	setReturnStatus (int status)

void	setCallType (RexxString *type)

void	pushBlock (RexxDoBlock *block)

void	popBlock ()

RexxDoBlock *	topBlock ()

void	terminateBlock (size_t _indent)

void	terminateBlock ()

void	newDo (RexxDoBlock *block)

void	removeBlock ()

void	addBlock ()

bool	hasActiveBlocks ()

bool	inMethod ()

void	indent ()

void	unindent ()

void	setIndent (size_t v)

size_t	getIndent ()

bool	tracingIntermediates ()

void	clearTraceSettings ()

bool	tracingResults ()

RexxActivity *	getActivity ()

RexxString *	getMessageName ()

RexxString *	getCallname ()

RexxInstruction *	getCurrent ()

void	getSettings (ActivationSettings &s)

void	putSettings (ActivationSettings &s)

RexxString *	getAddress ()

RexxDirectory *	getConditionObj ()

void	setConditionObj (RexxDirectory *condition)

RexxInstruction *	getNext ()

void	setNext (RexxInstruction *v)

void	setCurrent (RexxInstruction *v)

bool	inDebug ()

RexxExpressionStack *	getStack ()

virtual NumericSettings *	getNumericSettings ()

virtual RexxActivation *	getRexxContext ()

virtual RexxActivation *	findRexxContext ()

virtual RexxObject *	getReceiver ()

virtual bool	isRexxContext ()

void	traceIntermediate (RexxObject *v, int p)

void	traceVariable (RexxString n, RexxObject v)

void	traceDotVariable (RexxString n, RexxObject v)

void	traceFunction (RexxString n, RexxObject v)

void	traceMessage (RexxString n, RexxObject v)

void	traceOperator (const char n, RexxObject v)

void	tracePrefix (const char n, RexxObject v)

void	traceAssignment (RexxString n, RexxObject v, bool quoteValue=true)

void	traceCompoundName (RexxString stemVar, RexxObject tails, size_t tailCount, RexxCompoundTail tail)

void	traceCompoundName (RexxString stemVar, RexxObject tails, size_t tailCount, RexxString tail)

void	traceCompound (RexxString stemVar, RexxObject tails, size_t tailCount, RexxObject value)

void	traceCompoundAssignment (RexxString stemVar, RexxObject tails, size_t tailCount, RexxObject value, bool quoteValue=true)

void	traceResult (RexxObject *v)

bool	tracingInstructions (void)

bool	tracingErrors (void)

bool	tracingFailures (void)

void	traceInstruction (RexxInstruction *v)

void	traceLabel (RexxInstruction *v)

bool	tracingLabels (void)

void	traceCommand (RexxInstruction *v)

bool	tracingCommands (void)

bool	tracingAll (void)

void	pauseInstruction ()

int	conditionalPauseInstruction ()

void	pauseLabel ()

void	pauseCommand ()

SecurityManager *	getSecurityManager ()

SecurityManager *	getEffectiveSecurityManager ()

bool	isTopLevel ()

bool	isForwarded ()

bool	isGuarded ()

void	setGuarded ()

bool	isObjectScopeLocked ()

unsigned short	getReserveCount ()

RexxVariableDictionary *	getVariableDictionary ()

bool	isExternalTraceOn ()

void	setExternalTraceOn ()

void	setExternalTraceOff ()

void	enableExternalTrace (const char *option)

bool	isElapsedTimerReset ()

void	setElapsedTimerInvalid ()

void	setElapsedTimerValid ()

RexxObject **	getMethodArgumentList ()

size_t	getMethodArgumentCount ()

size_t	getMethodNamedArgumentCount ()

RexxObject *	getMethodArgument (size_t position)

void	setArguments (RexxArray positionalArguments, RexxDirectory namedArguments)

RexxArray *	getArguments ()

RexxObject **	getProgramArgumentlist ()

size_t	getProgramArgumentCount ()

size_t	getProgramNamedArgumentCount ()

RexxObject *	getProgramArgument (size_t position)

RexxObject *	getContextObject ()

RexxObject *	getContextLine ()

size_t	getContextLineNumber ()

RexxObject *	getContextReturnStatus ()

RexxObject *	getParentContextObject ()

StackFrameClass *	createStackFrame ()

RexxVariableDictionary *	getLocalVariables ()

RexxDirectory *	getAllLocalVariables ()

RexxVariable *	getLocalVariable (RexxString *name, size_t index)

RexxVariable *	getLocalStemVariable (RexxString *name, size_t index)

RexxStem *	getLocalStem (RexxString *name, size_t index)

void	dropLocalStem (RexxString *name, size_t index)

bool	localStemVariableExists (RexxString *stemName, size_t index)

bool	localVariableExists (RexxString *name, size_t index)

void	putLocalVariable (RexxVariable *variable, size_t index)

void	updateLocalVariable (RexxVariable *variable)

void	setLocalVariable (RexxString name, size_t index, RexxObject value)

void	dropLocalVariable (RexxString *name, size_t index)

RexxObject *	evaluateLocalCompoundVariable (RexxString stemName, size_t index, RexxObject *tail, size_t tailCount)

RexxObject *	getLocalCompoundVariableValue (RexxString stemName, size_t index, RexxObject *tail, size_t tailCount)

RexxObject *	getLocalCompoundVariableRealValue (RexxString localstem, size_t index, RexxObject *tail, size_t tailCount)

RexxCompoundElement *	getLocalCompoundVariable (RexxString stemName, size_t index, RexxObject *tail, size_t tailCount)

RexxCompoundElement *	exposeLocalCompoundVariable (RexxString stemName, size_t index, RexxObject *tail, size_t tailCount)

bool	localCompoundVariableExists (RexxString stemName, size_t index, RexxObject *tail, size_t tailCount)

void	assignLocalCompoundVariable (RexxString stemName, size_t index, RexxObject tail, size_t tailCount, RexxObject value)

void	setLocalCompoundVariable (RexxString stemName, size_t index, RexxObject tail, size_t tailCount, RexxObject value)

void	dropLocalCompoundVariable (RexxString stemName, size_t index, RexxObject *tail, size_t tailCount)

bool	novalueEnabled ()

RexxVariable *	newLocalVariable (RexxString *name)

void	cacheLocalVariable (RexxVariable *var)

void	cleanupLocalVariables ()

void	setLocalVariableDictionary (RexxVariableDictionary *dict)

Public Member Functions inherited from RexxActivationBase
	RexxActivationBase ()

	RexxActivationBase (RESTORETYPE restoreType)

virtual bool	isStackBase ()

void	setPreviousStackFrame (RexxActivationBase *p)

RexxActivationBase *	getPreviousStackFrame ()

BaseExecutable *	getExecutable ()

RexxObject *	getExecutableObject ()

Public Member Functions inherited from RexxInternalObject
void *	operator new (size_t, RexxClass *)

void *	operator new (size_t, RexxClass , RexxObject *, size_t, size_t)

void *	operator new (size_t size, void *ptr)

void	operator delete (void *)

void	operator delete (void p, void ptr)

	RexxInternalObject ()

	RexxInternalObject (RESTORETYPE restoreType)

virtual	~RexxInternalObject ()

	operator RexxObject * ()

size_t	getObjectSize ()

void	setObjectSize (size_t s)

size_t	getObjectDataSize ()

void *	getObjectDataSpace ()

void	clearObject ()

void	clearObject (size_t l)

void	setVirtualFunctions (void *t)

void	setInitHeader (size_t s, size_t markword)

void	setInitHeader (size_t markword)

void	setObjectLive (size_t markword)

void	setHasReferences ()

void	setHasNoReferences ()

bool	hasReferences ()

bool	hasNoReferences ()

void	setPrimitive ()

void	setNonPrimitive ()

bool	isPrimitive ()

bool	isNonPrimitive ()

bool	isObjectMarked (size_t markword)

void	setObjectMark (size_t markword)

void	clearObjectMark ()

bool	isObjectLive (size_t mark)

bool	isObjectDead (size_t mark)

bool	isOldSpace ()

bool	isNewSpace ()

void	setNewSpace ()

void	setOldSpace ()

void	makeProxiedObject ()

bool	isProxyObject ()

bool	isSubClassOrEnhanced ()

bool	isBaseClass ()

size_t	getObjectTypeNumber ()

RexxBehaviour *	getObjectType ()

bool	isObjectType (RexxBehaviour *b)

bool	isObjectType (size_t t)

bool	isSameType (RexxInternalObject *o)

void	setBehaviour (RexxBehaviour *b)

virtual RexxObject *	makeProxy (RexxEnvelope *)

virtual RexxObject *	copy ()

virtual RexxObject *	evaluate (RexxActivation , RexxExpressionStack )

virtual RexxObject *	getValue (RexxActivation *)

virtual RexxObject *	getValue (RexxVariableDictionary *)

virtual RexxObject *	getRealValue (RexxActivation *)

virtual RexxObject *	getRealValue (RexxVariableDictionary *)

virtual void	uninit ()

virtual HashCode	hash ()

virtual HashCode	getHashValue ()

HashCode	identityHash ()

virtual bool	truthValue (int)

virtual bool	logicalValue (logical_t &)

virtual RexxString *	makeString ()

virtual void	copyIntoTail (RexxCompoundTail *buffer)

virtual RexxString *	primitiveMakeString ()

virtual RexxArray *	makeArray ()

virtual RexxString *	stringValue ()

virtual RexxInteger *	integerValue (size_t)

virtual bool	numberValue (wholenumber_t &result, size_t precision)

virtual bool	numberValue (wholenumber_t &result)

virtual bool	unsignedNumberValue (stringsize_t &result, size_t precision)

virtual bool	unsignedNumberValue (stringsize_t &result)

virtual bool	doubleValue (double &result)

virtual RexxNumberString *	numberString ()

virtual bool	isEqual (RexxObject *)

virtual bool	isInstanceOf (RexxClass *)

virtual RexxMethod *	instanceMethod (RexxString *)

virtual RexxSupplier *	instanceMethods (RexxClass *)

void	hasUninit ()

void	removedUninit ()

void	printObject ()

RexxObject *	clone ()

Public Member Functions inherited from RexxVirtualBase
virtual void	flatten (RexxEnvelope *)

virtual RexxObject *	unflatten (RexxEnvelope *)

Static Public Member Functions
static size_t	processTraceSetting (size_t traceSetting)

static RoutineClass *	getMacroCode (RexxString *macroName)

Static Public Member Functions inherited from RexxInternalObject
static size_t	getObjectHeaderSize ()

Protected Attributes
ActivationSettings	settings

RexxExpressionStack	stack

RexxCode *	code

RexxSource *	sourceObject

RexxClass *	scope

RexxObject *	receiver

RexxActivity *	activity

RexxActivation *	parent

RexxArray *	arguments

RexxObject **	arglist

size_t	argcount

size_t	named_argcount

RexxDoBlock *	dostack

RexxInstruction *	current

RexxInstruction *	next

bool	debug_pause

int	object_scope

RexxObject *	result

RexxArray *	trapinfo

RexxContext *	contextObject

int	execution_state

int	activation_context

RexxMessage *	objnotify

RexxList *	environmentList

size_t	pending_count

RexxQueue *	handler_queue

RexxQueue *	condition_queue

uint64_t	random_seed

bool	random_set

size_t	blockNest

size_t	lookaside_size

Protected Attributes inherited from RexxActivationBase
RexxActivationBase *	previous

BaseExecutable *	executable

Static Protected Attributes
static const size_t	trace_off = 0x00000000

static const size_t	trace_debug = 0x00000001

static const size_t	trace_all = 0x00000002

static const size_t	trace_results = 0x00000004

static const size_t	trace_intermediates = 0x00000008

static const size_t	trace_commands = 0x00000010

static const size_t	trace_labels = 0x00000020

static const size_t	trace_errors = 0x00000040

static const size_t	trace_failures = 0x00000080

static const size_t	trace_suppress = 0x00000100

static const size_t	trace_flags = 0x000001ff

static const size_t	default_trace_flags = trace_failures

static const size_t	trace_all_flags = (trace_all \| trace_labels \| trace_commands)

static const size_t	trace_results_flags = (trace_all \| trace_labels \| trace_results \| trace_commands)

static const size_t	trace_intermediates_flags = (trace_all \| trace_labels \| trace_results \| trace_commands \| trace_intermediates)

static const bool	default_enable_commands = true

static const bool	default_enable_macrospace = true

static const size_t	single_step = 0x00000800

static const size_t	single_step_nested = 0x00001000

static const size_t	debug_prompt_issued = 0x00002000

static const size_t	debug_bypass = 0x00004000

static const size_t	procedure_valid = 0x00008000

static const size_t	clause_boundary = 0x00010000

static const size_t	halt_condition = 0x00020000

static const size_t	trace_on = 0x00040000

static const size_t	source_traced = 0x00080000

static const size_t	clause_exits = 0x00100000

static const size_t	external_yield = 0x00200000

static const size_t	forwarded = 0x00400000

static const size_t	reply_issued = 0x00800000

static const size_t	set_trace_on = 0x01000000

static const size_t	set_trace_off = 0x02000000

static const size_t	traps_copied = 0x04000000

static const size_t	return_status_set = 0x08000000

static const size_t	transfer_failed = 0x10000000

static const size_t	elapsed_reset = 0x20000000

static const size_t	guarded_method = 0x40000000

Friends
class	RexxSource

Additional Inherited Members
Public Attributes inherited from RexxInternalObject
ObjectHeader	header

RexxBehaviour *	behaviour

Protected Member Functions inherited from RexxVirtualBase
virtual	~RexxVirtualBase ()

virtual void	baseVirtual ()

Detailed Description

Definition at line 164 of file RexxActivation.hpp.

Constructor & Destructor Documentation

◆ RexxActivation() [1/5]

RexxActivation::RexxActivation ( RESTORETYPE restoreType )

inline

Definition at line 172 of file RexxActivation.hpp.

◆ RexxActivation() [2/5]

RexxActivation::RexxActivation ( )

Initialize an activation for direct caching in the activation cache. At this time, this is not an executable activation

Definition at line 148 of file RexxActivation.cpp.

References RexxInternalObject::setHasNoReferences().

◆ RexxActivation() [3/5]

RexxActivation::RexxActivation	(	RexxActivity *	_activity,
		RexxActivation *	_parent,
		RexxMethod *	_method,
		RexxCode *	_code
	)

Initialize an activation for a method invocation.

Parameters

_activity	The activity we're running under.
_method	The method being invoked.
_code	The code to execute.

Definition at line 161 of file RexxActivation.cpp.

◆ RexxActivation() [4/5]

RexxActivation::RexxActivation	(	RexxActivity *	_activity,
		RexxActivation *	_parent,
		RoutineClass *	_routine,
		RexxCode *	_code,
		RexxString *	calltype,
		RexxString *	env,
		int	context
	)

Create a top-level activation of Rexx code. This will either a toplevel program or an external call.

Parameters

_activity	The current thread we're running on.
_routine	The routine to invoke.
_code	The code object to be executed.
calltype	Type type of call being made (function or subroutine)
env	The default address environment
context	The type of call context.

Definition at line 359 of file RexxActivation.cpp.

◆ RexxActivation() [5/5]

RexxActivation::RexxActivation	(	RexxActivity *	_activity,
		RexxActivation *	_parent,
		RexxCode *	_code,
		int	context
	)

Create a new Rexx activation for an internal level call. An internal level call is an internal call, a call trap, an Interpret statement, or a debug pause execution.

Parameters

_activity	The current activity.
_parent	The parent activation.
_code	The code to be executed. For interpret and debug pauses, this is a new code object. For call activations, this is the parent code object.
context	The type of call being made.

Definition at line 284 of file RexxActivation.cpp.

References activation_context, ACTIVE, activity, adjustRandomSeed(), RexxActivity::allocateStackFrame(), RexxInternalObject::clearObject(), code, debug_pause, DEBUGPAUSE, RexxActivationBase::executable, execution_state, ActivationSettings::externalTraceDepth, ActivationSettings::flags, RexxActivationBase::getExecutable(), RexxCode::getMaxStackSize(), BaseExecutable::getSourceObject(), RexxCode::getSourceObject(), ActivationSettings::intermediate_trace, INTERNALCALL, INTERPRET, ActivationSettings::local_variables, object_scope, parent, putSettings(), reply_issued, SCOPE_RELEASED, RexxInternalObject::setHasNoReferences(), RexxInternalObject::setHasReferences(), RexxLocalVariables::setNested(), settings, sourceObject, stack, ActivationSettings::timestamp, ActivationSettings::traceindent, ActivationSettings::traceOption, traps_copied, and RexxDateTime::valid.

Member Function Documentation

◆ addBlock()

void RexxActivation::addBlock ( )

inline

Definition at line 381 of file RexxActivation.hpp.

References blockNest, and indent().

Referenced by RexxInstructionDo::execute().

◆ addLocalRoutine()

void RexxActivation::addLocalRoutine	(	RexxString *	name,
		RexxMethod *	_method
	)

Add a local routine to the current activation's routine set.

Parameters

name	The name to add this under.
method	The method associated with the name.

Definition at line 4291 of file RexxActivation.cpp.

References RexxCode::getLocalRoutines(), RexxCode::getSourceObject(), new_directory(), OREF_NULL, ActivationSettings::parent_code, RexxDirectory::setEntry(), RexxSource::setLocalRoutines(), and settings.

◆ adjustRandomSeed()

void RexxActivation::adjustRandomSeed ( )

inline

Definition at line 350 of file RexxActivation.hpp.

References random_seed.

Referenced by RexxActivation().

◆ assignLocalCompoundVariable()

void RexxActivation::assignLocalCompoundVariable	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount,
		RexxObject *	value
	)

Definition at line 4505 of file RexxActivation.cpp.

References getLocalStem(), RexxStem::setCompoundVariable(), traceCompoundAssignment(), traceCompoundName(), and tracingIntermediates().

Referenced by RexxCompoundVariable::assign().

◆ cacheLocalVariable()

void RexxActivation::cacheLocalVariable ( RexxVariable * var )

inline

Definition at line 613 of file RexxActivation.hpp.

References RexxVariable::cache(), memoryObject, and RexxMemory::variableCache.

Referenced by cleanupLocalVariables().

◆ callExternalRexx()

bool RexxActivation::callExternalRexx	(	RexxString *	target,
		RexxObject **	_arguments,
		size_t	_argcount,
		size_t	_named_argcount,
		RexxString *	calltype,
		ProtectedObject &	resultObj
	)

Call an external program as a function or subroutine.

Parameters

target	The target function name.
parent	The name of the parent program (used for resolving extensions).
_arguments	The arguments to the call.
_argcount	The count of positional arguments for the call.
calltype	The type of call (FUNCTION or SUBROUTINE)
resultObj	The returned result.

Returns: True if an external program was located and called. false for any failures.

Definition at line 2922 of file RexxActivation.cpp.

References activity, RoutineClass::call(), ActivationSettings::current_env, EXTERNALCALL, RoutineClass::fromFile(), BaseExecutable::getSourceObject(), RexxCode::mergeRequired(), OREF_NULL, ActivationSettings::parent_code, RexxExpressionStack::pop(), RexxExpressionStack::push(), resolveProgramName(), settings, and stack.

Referenced by SystemInterpreter::invokeExternalFunction().

◆ callMacroSpaceFunction()

bool RexxActivation::callMacroSpaceFunction	(	RexxString *	target,
		RexxObject **	_arguments,
		size_t	_argcount,
		size_t	_named_argcount,
		RexxString *	calltype,
		int	order,
		ProtectedObject &	_result
	)

Attempt to call a function stored in the macrospace.

Parameters

target	The target function name.
arguments	The argument pointer.
argcount	The count of positional arguments,
calltype	The type of call (FUNCTION or SUBROUTINE)
order	The macrospace order flag.
result	The function result.

Returns: true if the macrospace function was located and called.

Definition at line 2808 of file RexxActivation.cpp.

References activity, RoutineClass::call(), enableMacrospace(), EXTERNALCALL, getMacroCode(), BaseExecutable::getSourceObject(), getSourceObject(), RexxString::getStringData(), RexxSource::mergeRequired(), MS_PREORDER, OREF_NULL, RexxQueryMacro(), and RXMACRO_SEARCH_AFTER.

Referenced by SystemInterpreter::invokeExternalFunction().

◆ checkTrapTable()

void RexxActivation::checkTrapTable ( )

Definition at line 1587 of file RexxActivation.cpp.

References RexxDirectory::copy(), ActivationSettings::flags, isInternalCall(), new_directory(), OREF_NULL, settings, ActivationSettings::traps, and traps_copied.

Referenced by trapDelay(), trapOff(), trapOn(), and trapUndelay().

◆ cleanupLocalVariables()

void RexxActivation::cleanupLocalVariables ( )

inline

Definition at line 619 of file RexxActivation.hpp.

References cacheLocalVariable(), RexxLocalVariables::get(), RexxLocalVariables::getNestedDictionary(), isInternalLevelCall(), RexxVariable::isLocal(), RexxLocalVariables::isNested(), ActivationSettings::local_variables, OREF_NULL, parent, setLocalVariableDictionary(), settings, and RexxLocalVariables::size.

Referenced by termination().

◆ clearTraceSettings()

void RexxActivation::clearTraceSettings ( )

inline

Definition at line 389 of file RexxActivation.hpp.

References ActivationSettings::flags, ActivationSettings::intermediate_trace, settings, and trace_flags.

Referenced by setTrace().

◆ closeStreams()

void RexxActivation::closeStreams ( )

Definition at line 4384 of file RexxActivation.cpp.

References RexxDirectory::at(), RexxHashTableCollection::first(), RexxHashTableCollection::index(), isProgramOrMethod(), RexxHashTableCollection::next(), OREF_NULL, RexxObject::sendMessage(), settings, and ActivationSettings::streams.

Referenced by termination().

◆ command()

void RexxActivation::command	(	RexxString *	address,
		RexxString *	commandString
	)

Issue a command to a named host evironment

Parameters

commandString	The command to issue
address	The target address

Returns: The return code object

Definition at line 4097 of file RexxActivation.cpp.

References activity, RexxDirectory::at(), CommandHandler::call(), RexxActivity::callCommandExit(), RexxString::concatToCstring(), RexxString::concatWithCstring(), RexxActivity::createConditionObject(), current, debug_pause, debugPause(), inDebug(), new_integer(), RexxObject::numberValue(), OREF_NULL, RexxDirectory::put(), RexxActivity::raiseCondition(), RexxActivity::resolveCommandHandler(), RETURN_STATUS_ERROR, RETURN_STATUS_FAILURE, RETURN_STATUS_NORMAL, RXSUBCOM_NOTREG, setLocalVariable(), setReturnStatus(), RexxString::strCompare(), RexxObject::stringValue(), TheFalseObject, TRACE_PREFIX_CLAUSE, TRACE_PREFIX_ERROR, TRACE_PREFIX_RESULT, traceClause(), traceValue(), tracingAll(), tracingCommands(), tracingErrors(), tracingFailures(), and VARIABLE_RC.

Referenced by RexxInstructionAddress::execute(), and RexxInstructionCommand::execute().

◆ conditionalPauseInstruction()

int RexxActivation::conditionalPauseInstruction ( )

inline

Definition at line 443 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, trace_all, and trace_debug.

Referenced by RexxInstructionDo::execute(), RexxInstructionInterpret::execute(), and RexxInstructionSelect::execute().

◆ createStackFrame()

StackFrameClass * RexxActivation::createStackFrame ( )

Create a stack frame for exception tracebacks.

Returns: A StackFrame instance for this activation.

Definition at line 4608 of file RexxActivation.cpp.

References arguments, FRAME_INTERNAL_CALL, FRAME_INTERPRET, FRAME_METHOD, FRAME_PROGRAM, FRAME_ROUTINE, getArguments(), getContextLineNumber(), RexxActivationBase::getExecutableObject(), getMessageName(), getTraceBack(), isInternalCall(), isInterpret(), isMethod(), isProgram(), isRoutine(), OREF_NULL, receiver, and type.

Referenced by RexxActivationFrame::createStackFrame().

◆ currentLine()

size_t RexxActivation::currentLine ( )

Definition at line 1340 of file RexxActivation.cpp.

References current, RexxInstruction::getLineNumber(), and OREF_NULL.

Referenced by RexxActivity::reraiseException().

◆ debugInterpret()

void RexxActivation::debugInterpret ( RexxString * codestring )

Definition at line 2586 of file RexxActivation.cpp.

References activity, argcount, arglist, arguments, code, current, debug_pause, DEBUGPAUSE, RexxInstruction::getLineNumber(), RexxCode::interpret(), ActivationSettings::msgname, named_argcount, ActivityManager::newActivation(), OREF_NULL, RexxActivity::pushStackFrame(), receiver, run(), and settings.

Referenced by debugPause().

◆ debugPause()

bool RexxActivation::debugPause ( RexxInstruction * instr = OREF_NULL )

Definition at line 3979 of file RexxActivation.cpp.

References activity, code, current, debug_bypass, debug_pause, debug_prompt_issued, debugInterpret(), ActivationSettings::flags, RexxString::getBLength(), RexxString::getCharB(), SystemInterpreter::getMessageText(), RexxCode::isTraceable(), Message_Translations_debug_prompt, next, settings, ActivationSettings::trace_skip, trace_suppress, RexxActivity::traceInput(), and RexxActivity::traceOutput().

Referenced by command(), pauseCommand(), pauseInstruction(), and pauseLabel().

◆ debugSkip()

void RexxActivation::debugSkip	(	wholenumber_t	skipcount,
		bool	notrace
	)

Definition at line 840 of file RexxActivation.cpp.

References debug_bypass, debug_pause, Error_Invalid_trace_debug, ActivationSettings::flags, reportException(), settings, ActivationSettings::trace_skip, and trace_suppress.

Referenced by RexxInstructionTrace::execute().

◆ digits()

size_t RexxActivation::digits ( )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2073 of file RexxActivation.cpp.

References NumericSettings::digits, ActivationSettings::numericSettings, and settings.

Referenced by RexxInstructionDo::controlSetup(), RexxNativeActivation::digits(), RexxInstructionDo::execute(), RexxInstructionNumeric::execute(), and RexxContext::getDigits().

◆ directRetriever()

RexxVariableBase* RexxActivation::directRetriever ( RexxString * )

◆ dispatch()

RexxObject * RexxActivation::dispatch ( )

virtual

Reimplemented from RexxActivationBase.

Definition at line 473 of file RexxActivation.cpp.

References argcount, arglist, arguments, ActivationSettings::msgname, named_argcount, OREF_NULL, receiver, run(), and settings.

◆ dropLocalCompoundVariable()

void RexxActivation::dropLocalCompoundVariable	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4534 of file RexxActivation.cpp.

References RexxStem::dropCompoundVariable(), getLocalStem(), traceCompoundAssignment(), traceCompoundName(), and tracingIntermediates().

Referenced by RexxCompoundVariable::drop().

◆ dropLocalStem()

void RexxActivation::dropLocalStem	(	RexxString *	name,
		size_t	index
	)

inline

Definition at line 536 of file RexxActivation.hpp.

References getLocalStemVariable(), and RexxVariable::set().

Referenced by RexxStemVariable::drop().

◆ dropLocalVariable()

void RexxActivation::dropLocalVariable	(	RexxString *	name,
		size_t	index
	)

inline

Definition at line 575 of file RexxActivation.hpp.

References RexxVariable::drop(), and getLocalVariable().

Referenced by RexxParseVariable::drop(), RexxInstructionCall::execute(), RexxInstructionCommand::execute(), RexxInstructionForward::execute(), and RexxInstructionMessage::execute().

◆ enableCommands() [1/2]

bool RexxActivation::enableCommands ( )

Definition at line 2105 of file RexxActivation.cpp.

References ActivationSettings::enableCommands, and settings.

Referenced by RexxInstructionCommand::execute(), and RexxInstructionOptions::execute().

◆ enableCommands() [2/2]

void RexxActivation::enableCommands ( bool status )

Definition at line 2187 of file RexxActivation.cpp.

References ActivationSettings::enableCommands, and settings.

◆ enableExternalTrace()

void RexxActivation::enableExternalTrace ( const char * option )

Turn on external trace at program startup (e.g, because RXTRACE is set)

Definition at line 3893 of file RexxActivation.cpp.

References DEBUG_ON, new_string(), setTrace(), SIZE_MAX, RexxString::strCaselessCompare(), stringsizeB_v, trace_debug, TRACE_RESULTS, and trace_results_flags.

Referenced by SysInterpreterInstance::setupProgram().

◆ enableMacrospace() [1/2]

bool RexxActivation::enableMacrospace ( )

Definition at line 2113 of file RexxActivation.cpp.

References ActivationSettings::enableMacrospace, and settings.

Referenced by callMacroSpaceFunction(), and RexxInstructionOptions::execute().

◆ enableMacrospace() [2/2]

void RexxActivation::enableMacrospace ( bool status )

Definition at line 2195 of file RexxActivation.cpp.

References ActivationSettings::enableMacrospace, and settings.

◆ evaluateLocalCompoundVariable()

RexxObject * RexxActivation::evaluateLocalCompoundVariable	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4437 of file RexxActivation.cpp.

References RexxStem::evaluateCompoundVariableValue(), getLocalStem(), traceCompound(), traceCompoundName(), and tracingIntermediates().

Referenced by RexxCompoundVariable::evaluate().

◆ exitFrom()

void RexxActivation::exitFrom ( RexxObject * resultObj )

Definition at line 1484 of file RexxActivation.cpp.

References activity, RexxActivity::callTerminationExit(), ActivityManager::currentActivity, debug_bypass, Error_Execution_reply_exit, execution_state, exitFrom(), ActivationSettings::flags, RexxActivity::getCurrentRexxFrame(), isProgramLevelCall(), isTopLevel(), isTopLevelCall(), next, OREF_NULL, RexxActivity::popStackFrame(), reply_issued, reportException(), result, RETURNED, settings, termination(), and trace_debug.

Referenced by RexxInstructionExit::execute(), exitFrom(), implicitExit(), and raiseExit().

◆ expose()

void RexxActivation::expose	(	RexxVariableBase **	variables,
		size_t	count
	)

Definition at line 1385 of file RexxActivation.cpp.

References RexxVariableBase::expose(), getObjectVariables(), and stack.

Referenced by RexxInstructionExpose::execute().

◆ exposeLocalCompoundVariable()

RexxCompoundElement * RexxActivation::exposeLocalCompoundVariable	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4485 of file RexxActivation.cpp.

References RexxStem::exposeCompoundVariable(), and getLocalStem().

Referenced by RexxCompoundVariable::procedureExpose().

◆ external()

RexxActivation * RexxActivation::external ( )

Definition at line 1650 of file RexxActivation.cpp.

References external(), isInternalLevelCall(), and parent.

Referenced by external().

◆ externalCall()

RexxObject * RexxActivation::externalCall	(	RexxString *	target,
		RexxObject **	_arguments,
		size_t	_argcount,
		size_t	_named_argcount,
		RexxString *	calltype,
		ProtectedObject &	resultObj
	)

Main method for performing an external routine call. This orchestrates the search order for locating an external routine.

Parameters

target	The target function name.
_argcount	The count of positional arguments for the call.
_stack	The expression stack holding the arguments.
calltype	The type of call (FUNCTION or SUBROUTINE)
resultObj	The returned result.

Returns: The function result (also returned in the resultObj protected object reference.

Definition at line 2854 of file RexxActivation.cpp.

References activity, RoutineClass::call(), RexxActivity::callFunctionExit(), RexxActivity::callObjectFunctionExit(), RexxActivity::callScriptingExit(), Error_Routine_not_found_name, EXTERNALCALL, RexxCode::findRoutine(), SystemInterpreter::invokeExternalFunction(), OREF_NULL, ActivationSettings::parent_code, reportException(), settings, and TheFunctionsDirectory.

Referenced by RexxExpressionFunction::evaluate(), RexxInstructionCall::execute(), and RexxInstructionCall::trap().

◆ externalTraceOff()

void RexxActivation::externalTraceOff ( )

Definition at line 3967 of file RexxActivation.cpp.

References clause_boundary, ActivationSettings::flags, set_trace_off, and settings.

Referenced by RexxActivity::callTraceTestExit(), and RexxActivity::setTrace().

◆ externalTraceOn()

void RexxActivation::externalTraceOn ( )

Definition at line 3954 of file RexxActivation.cpp.

References clause_boundary, DEBUG_ON, ActivationSettings::flags, set_trace_on, settings, setTrace(), trace_debug, TRACE_RESULTS, and trace_results_flags.

Referenced by RexxActivity::callTraceTestExit(), and RexxActivity::setTrace().

◆ findClass()

RexxClass * RexxActivation::findClass ( RexxString * name )

Resolve a class in this activation's context.

Parameters

name	The name to resolve.

Returns: The resolved class, or OREF_NULL if not found.

Definition at line 3017 of file RexxActivation.cpp.

References RexxSource::findClass(), getSourceObject(), RexxObject::isInstanceOf(), OREF_NULL, and TheClassClass.

Referenced by RexxNativeActivation::findCallerClass().

◆ findRexxContext()

RexxActivation * RexxActivation::findRexxContext ( )

virtual

Return the Rexx context this operates under. Depending on the context, this could be null.

Returns: The parent Rexx context.

Reimplemented from RexxActivationBase.

Definition at line 2222 of file RexxActivation.cpp.

◆ form()

bool RexxActivation::form ( )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2089 of file RexxActivation.cpp.

References NumericSettings::form, ActivationSettings::numericSettings, and settings.

Referenced by RexxNativeActivation::form(), and RexxContext::getForm().

◆ formatSourcelessTraceLine()

RexxString * RexxActivation::formatSourcelessTraceLine ( RexxString * packageName )

Format a more informative trace line when giving traceback information for code when no source code is available.

Parameters

packageName The package name to use (could be "REXX" for internal code)

Returns: A formatted descriptive string for the invocation.

Definition at line 4660 of file RexxActivation.cpp.

References activity, RexxActivity::buildMessage(), RexxClass::getId(), getMessageName(), isMethod(), isRoutine(), Message_Translations_sourceless_method_invocation, Message_Translations_sourceless_program_invocation, Message_Translations_sourceless_routine_invocation, new_array(), RexxObject::requestString(), scope, and TheNilObject.

Referenced by RexxSource::traceBack().

◆ formatTrace()

RexxString * RexxActivation::formatTrace	(	RexxInstruction *	instruction,
		RexxSource *	_source
	)

Definition at line 3788 of file RexxActivation.cpp.

References RexxInstruction::getLocation(), MAX_TRACEBACK_INDENT, OREF_NULL, settings, RexxSource::traceBack(), and ActivationSettings::traceindent.

Referenced by getTraceBack(), and traceClause().

◆ forward()

RexxObject * RexxActivation::forward	(	RexxObject *	target,
		RexxString *	message,
		RexxObject *	superClass,
		RexxObject **	_arguments,
		size_t	_argcount,
		size_t	_named_argcount,
		bool	continuing
	)

Definition at line 1402 of file RexxActivation.cpp.

References argcount, arglist, debug_bypass, Error_Execution_reply_exit, execution_state, ActivationSettings::flags, forwarded, RexxObject::messageSend(), ActivationSettings::msgname, named_argcount, next, OREF_NULL, receiver, reply_issued, reportException(), result, RETURNED, settings, termination(), and trace_debug.

Referenced by RexxInstructionForward::execute().

◆ fuzz()

size_t RexxActivation::fuzz ( )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2081 of file RexxActivation.cpp.

References NumericSettings::fuzz, ActivationSettings::numericSettings, and settings.

Referenced by RexxInstructionNumeric::execute(), RexxNativeActivation::fuzz(), and RexxContext::getFuzz().

◆ getActivity()

RexxActivity* RexxActivation::getActivity ( )

inline

Definition at line 391 of file RexxActivation.hpp.

References activity.

Referenced by RexxInstructionSay::execute().

◆ getAddress()

RexxString* RexxActivation::getAddress ( )

inline

Definition at line 397 of file RexxActivation.hpp.

References ActivationSettings::current_env, and settings.

Referenced by RexxInstructionCommand::execute().

◆ getAllLocalVariables()

RexxDirectory* RexxActivation::getAllLocalVariables ( )

inline

Definition at line 508 of file RexxActivation.hpp.

References RexxVariableDictionary::getAllVariables(), and getLocalVariables().

Referenced by RexxNativeActivation::getAllContextVariables(), and RexxContext::getVariables().

◆ getArguments()

RexxArray* RexxActivation::getArguments ( )

inline

Definition at line 481 of file RexxActivation.hpp.

References argcount, arglist, and new_array().

Referenced by createStackFrame().

◆ getCallname()

RexxString* RexxActivation::getCallname ( )

inline

Definition at line 393 of file RexxActivation.hpp.

References ActivationSettings::msgname, and settings.

Referenced by RexxInstructionUseStrict::executeNamedArguments(), RexxInstructionUseStrict::executePositionalArguments(), and RexxContext::getName().

◆ getConditionObj()

RexxDirectory* RexxActivation::getConditionObj ( )

inline

Definition at line 398 of file RexxActivation.hpp.

References ActivationSettings::conditionObj, and settings.

Referenced by RexxInstructionRaise::execute(), and RexxContext::getCondition().

◆ getContextLine()

RexxObject * RexxActivation::getContextLine ( )

Return the line context information for a context.

Returns: The current execution line.

Definition at line 2727 of file RexxActivation.cpp.

References current, getContextLine(), RexxInstruction::getLineNumber(), isInterpret(), new_integer(), and parent.

Referenced by getContextLine(), and RexxContext::getLine().

◆ getContextLineNumber()

size_t RexxActivation::getContextLineNumber ( )

Return the line context information for a context.

Returns: The current execution line.

Definition at line 2748 of file RexxActivation.cpp.

References current, getContextLineNumber(), RexxInstruction::getLineNumber(), isInterpret(), and parent.

Referenced by createStackFrame(), and getContextLineNumber().

◆ getContextObject()

RexxObject * RexxActivation::getContextObject ( )

Get the context object for this activation.

Returns: The created context object.

Definition at line 2710 of file RexxActivation.cpp.

References contextObject, and OREF_NULL.

Referenced by RexxSourceLiteral::evaluate(), getParentContextObject(), RexxNativeActivation::getRexxContextObject(), and rexxVariable().

◆ getContextReturnStatus()

RexxObject * RexxActivation::getContextReturnStatus ( )

Return the RS context information for a activation.

Returns: The current execution line.

Definition at line 2769 of file RexxActivation.cpp.

References ActivationSettings::flags, new_integer(), ActivationSettings::return_status, return_status_set, settings, and TheNilObject.

Referenced by RexxContext::getRS().

◆ getCurrent()

RexxInstruction* RexxActivation::getCurrent ( )

inline

Definition at line 394 of file RexxActivation.hpp.

References current.

◆ getEffectiveSecurityManager()

SecurityManager * RexxActivation::getEffectiveSecurityManager ( )

Get the security manager in used by this activation.

Returns: Either the defined security manager or the instance-global security manager.

Definition at line 4570 of file RexxActivation.cpp.

References activity, RexxActivity::getInstanceSecurityManager(), OREF_NULL, ActivationSettings::securityManager, and settings.

Referenced by RexxActivity::callCommandExit(), RexxActivity::callObjectFunctionExit(), and resolveStream().

◆ getEffectiveSourceObject()

RexxSource* RexxActivation::getEffectiveSourceObject ( )

inline

Definition at line 365 of file RexxActivation.hpp.

References RexxActivationBase::executable, BaseExecutable::getSourceObject(), isInterpret(), and sourceObject.

Referenced by RexxActivationFrame::getSource().

◆ getElapsed()

int64_t RexxActivation::getElapsed ( )

Definition at line 3216 of file RexxActivation.cpp.

References ActivationSettings::elapsed_time, RexxDateTime::getUTCBaseTime(), settings, and ActivationSettings::timestamp.

◆ getIndent()

size_t RexxActivation::getIndent ( )

inline

Definition at line 387 of file RexxActivation.hpp.

References settings, and ActivationSettings::traceindent.

Referenced by RexxInstructionDo::execute(), and RexxInstructionSelect::execute().

◆ getLabels()

RexxDirectory * RexxActivation::getLabels ( )

Definition at line 4267 of file RexxActivation.cpp.

References code, and RexxCode::getLabels().

Referenced by RexxInstructionCall::execute(), and signalValue().

◆ getLocalCompoundVariable()

RexxCompoundElement * RexxActivation::getLocalCompoundVariable	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4475 of file RexxActivation.cpp.

References RexxStem::getCompoundVariable(), and getLocalStem().

Referenced by RexxCompoundVariable::clearGuard(), and RexxCompoundVariable::setGuard().

◆ getLocalCompoundVariableRealValue()

RexxObject * RexxActivation::getLocalCompoundVariableRealValue	(	RexxString *	localstem,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4465 of file RexxActivation.cpp.

References RexxStem::getCompoundVariableRealValue(), and getLocalStem().

Referenced by RexxCompoundVariable::getRealValue().

◆ getLocalCompoundVariableValue()

RexxObject * RexxActivation::getLocalCompoundVariableValue	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4455 of file RexxActivation.cpp.

References RexxStem::getCompoundVariableValue(), and getLocalStem().

Referenced by RexxCompoundVariable::getValue().

◆ getLocalEnvironment()

RexxObject * RexxActivation::getLocalEnvironment ( RexxString * name )

Retrieve a value from the instance local environment.

Parameters

name	The name of the .local object.

Returns: The object stored at the given name.

Definition at line 4588 of file RexxActivation.cpp.

References activity, and RexxActivity::getLocalEnvironment().

Referenced by novalueHandler(), and resolveStream().

◆ getLocalStem()

RexxStem* RexxActivation::getLocalStem	(	RexxString *	name,
		size_t	index
	)

inline

Definition at line 531 of file RexxActivation.hpp.

References getLocalStemVariable(), and RexxVariable::getVariableValue().

Referenced by assignLocalCompoundVariable(), dropLocalCompoundVariable(), RexxStemVariable::evaluate(), evaluateLocalCompoundVariable(), RexxCompoundVariable::expose(), exposeLocalCompoundVariable(), getLocalCompoundVariable(), getLocalCompoundVariableRealValue(), getLocalCompoundVariableValue(), RexxStemVariable::getRealValue(), RexxStemVariable::getValue(), localCompoundVariableExists(), RexxCompoundVariable::procedureExpose(), setLocalCompoundVariable(), and RexxStemVariable::sort().

◆ getLocalStemVariable()

RexxVariable* RexxActivation::getLocalStemVariable	(	RexxString *	name,
		size_t	index
	)

inline

Definition at line 522 of file RexxActivation.hpp.

References RexxLocalVariables::get(), ActivationSettings::local_variables, RexxLocalVariables::lookupStemVariable(), OREF_NULL, and settings.

Referenced by RexxStemVariable::assign(), RexxStemVariable::clearGuard(), dropLocalStem(), getLocalStem(), RexxStemVariable::procedureExpose(), RexxStemVariable::set(), and RexxStemVariable::setGuard().

◆ getLocalVariable()

RexxVariable* RexxActivation::getLocalVariable	(	RexxString *	name,
		size_t	index
	)

inline

Definition at line 513 of file RexxActivation.hpp.

References RexxLocalVariables::get(), ActivationSettings::local_variables, RexxLocalVariables::lookupVariable(), OREF_NULL, and settings.

Referenced by RexxParseVariable::clearGuard(), dropLocalVariable(), RexxParseVariable::evaluate(), RexxParseVariable::getRealValue(), RexxParseVariable::getValue(), RexxParseVariable::procedureExpose(), RexxParseVariable::setGuard(), and setLocalVariable().

◆ getLocalVariables()

RexxVariableDictionary* RexxActivation::getLocalVariables ( )

inline

Definition at line 503 of file RexxActivation.hpp.

References RexxLocalVariables::getDictionary(), ActivationSettings::local_variables, and settings.

Referenced by RexxNativeActivation::fetchNext(), and getAllLocalVariables().

◆ getMacroCode()

RoutineClass * RexxActivation::getMacroCode ( RexxString * macroName )

static

Retrieve a macro image file from the macro space.

Parameters

macroName The name of the macro to retrieve.

Returns: If available, the unflattened method image.

Definition at line 2969 of file RexxActivation.cpp.

References RexxString::getStringData(), OREF_NULL, SystemInterpreter::releaseResultMemory(), RoutineClass::restore(), RexxResolveMacroFunction(), and _RXSTRING::strptr.

Referenced by callMacroSpaceFunction(), and PackageManager::getMacroSpaceRequires().

◆ getMessageName()

RexxString* RexxActivation::getMessageName ( )

inline

Definition at line 392 of file RexxActivation.hpp.

References ActivationSettings::msgname, and settings.

Referenced by createStackFrame(), formatSourcelessTraceLine(), RexxActivationFrame::messageName(), and traceEntry().

◆ getMethodArgument()

RexxObject* RexxActivation::getMethodArgument ( size_t position )

inline

Definition at line 471 of file RexxActivation.hpp.

References arglist, getMethodArgumentCount(), OREF_NULL, and RexxSource::position().

◆ getMethodArgumentCount()

size_t RexxActivation::getMethodArgumentCount ( )

inline

Definition at line 469 of file RexxActivation.hpp.

References argcount.

Referenced by RexxInstructionForward::execute(), RexxInstructionParse::execute(), RexxInstructionUseStrict::executeNamedArguments(), RexxInstructionUseStrict::executePositionalArguments(), RexxContext::getArgs(), getMethodArgument(), and RexxContext::getNamedArgs().

◆ getMethodArgumentList()

RexxObject** RexxActivation::getMethodArgumentList ( )

inline

Definition at line 468 of file RexxActivation.hpp.

References arglist.

Referenced by RexxInstructionForward::execute(), RexxInstructionParse::execute(), RexxInstructionUseStrict::executeNamedArguments(), RexxInstructionUseStrict::executePositionalArguments(), RexxContext::getArgs(), and RexxContext::getNamedArgs().

◆ getMethodNamedArgumentCount()

size_t RexxActivation::getMethodNamedArgumentCount ( )

inline

Definition at line 470 of file RexxActivation.hpp.

References named_argcount.

Referenced by RexxInstructionForward::execute(), RexxInstructionUseStrict::executeNamedArguments(), and RexxContext::getNamedArgs().

◆ getNext()

RexxInstruction* RexxActivation::getNext ( )

inline

Definition at line 400 of file RexxActivation.hpp.

References next.

◆ getNumericSettings()

NumericSettings * RexxActivation::getNumericSettings ( )

virtual

Get the numeric settings for the current context.

Returns: The new numeric settings.

Reimplemented from RexxActivationBase.

Definition at line 2244 of file RexxActivation.cpp.

References ActivationSettings::numericSettings, and settings.

Referenced by RexxNativeActivation::getNumericSettings().

◆ getObjectVariables()

RexxVariableDictionary * RexxActivation::getObjectVariables ( )

Definition at line 1812 of file RexxActivation.cpp.

References activity, RexxObject::getObjectVariables(), isGuarded(), object_scope, ActivationSettings::object_variables, OREF_NULL, receiver, RexxVariableDictionary::reserve(), scope, SCOPE_RESERVED, and settings.

Referenced by expose().

◆ getPackage()

PackageClass * RexxActivation::getPackage ( )

Retrieve the package for the current execution context.

Returns: The Package holding the code for the current execution context.

Definition at line 4431 of file RexxActivation.cpp.

References RexxActivationBase::executable, and BaseExecutable::getPackage().

Referenced by RexxContext::getPackage(), and traceEntry().

◆ getParentContextObject()

RexxObject * RexxActivation::getParentContextObject ( )

Get the context object for the parent of this activation.

Returns: The created context object.

Definition at line 2788 of file RexxActivation.cpp.

References getContextObject(), OREF_NULL, senderActivation(), and TheNilObject.

Referenced by RexxContext::getParentContextObject().

◆ getProgramArgument()

RexxObject* RexxActivation::getProgramArgument ( size_t position )

inline

Definition at line 487 of file RexxActivation.hpp.

References getProgramArgumentCount(), OREF_NULL, ActivationSettings::parent_arglist, RexxSource::position(), and settings.

Referenced by RexxNativeActivation::variablePoolFetchPrivate().

◆ getProgramArgumentCount()

size_t RexxActivation::getProgramArgumentCount ( )

inline

Definition at line 484 of file RexxActivation.hpp.

References ActivationSettings::parent_argcount, and settings.

Referenced by getProgramArgument(), and RexxNativeActivation::variablePoolFetchPrivate().

◆ getProgramArgumentlist()

RexxObject** RexxActivation::getProgramArgumentlist ( )

inline

Definition at line 483 of file RexxActivation.hpp.

References ActivationSettings::parent_arglist, and settings.

◆ getProgramName()

RexxString * RexxActivation::getProgramName ( )

Definition at line 4259 of file RexxActivation.cpp.

References code, and RexxCode::getProgramName().

◆ getProgramNamedArgumentCount()

size_t RexxActivation::getProgramNamedArgumentCount ( )

inline

Definition at line 485 of file RexxActivation.hpp.

References ActivationSettings::parent_named_argcount, and settings.

◆ getPublicRoutines()

RexxDirectory * RexxActivation::getPublicRoutines ( )

Retrieve the directory of public routines associated with the current activation.

Returns: A directory of the public routines.

Definition at line 4314 of file RexxActivation.cpp.

References code, and RexxCode::getPublicRoutines().

◆ getRandomSeed()

uint64_t RexxActivation::getRandomSeed ( RexxInteger * seed )

Definition at line 3251 of file RexxActivation.cpp.

References activity, Error_Incorrect_call_nonnegative, getRandomSeed(), RexxInteger::getValue(), IntegerThree, isInternalLevelCall(), OREF_NULL, parent, random_seed, RANDOMIZE(), reportException(), and RexxActivity::setRandomSeed().

Referenced by getRandomSeed(), and random().

◆ getReceiver()

RexxObject * RexxActivation::getReceiver ( )

virtual

Get the message receiver

Returns: The message receiver. Returns OREF_NULL if this is not a message activation.

Reimplemented from RexxActivationBase.

Definition at line 2256 of file RexxActivation.cpp.

References getReceiver(), isInterpret(), parent, and receiver.

Referenced by RexxExpressionMessage::assign(), RexxExpressionMessage::evaluate(), RexxInstructionMessage::execute(), and getReceiver().

◆ getReserveCount()

unsigned short RexxActivation::getReserveCount ( )

inline

Definition at line 455 of file RexxActivation.hpp.

References RexxVariableDictionary::getReserveCount(), and getVariableDictionary().

Referenced by RexxActivity::traceOutput().

◆ getRexxContext()

RexxActivation * RexxActivation::getRexxContext ( )

virtual

Return the Rexx context this operates under. Depending on the context, this could be null.

Returns: The parent Rexx context.

Reimplemented from RexxActivationBase.

Definition at line 2210 of file RexxActivation.cpp.

◆ getSecurityManager()

SecurityManager * RexxActivation::getSecurityManager ( )

virtual

Get the security manager in effect for a given context.

Returns: The security manager defined for this activation context.

Implements RexxActivationBase.

Definition at line 4558 of file RexxActivation.cpp.

References ActivationSettings::securityManager, and settings.

◆ getSettings()

void RexxActivation::getSettings ( ActivationSettings & s )

inline

Definition at line 395 of file RexxActivation.hpp.

References settings.

Referenced by run().

◆ getSourceObject()

RexxSource* RexxActivation::getSourceObject ( )

inline

Definition at line 364 of file RexxActivation.hpp.

References sourceObject.

Referenced by callMacroSpaceFunction(), findClass(), getTraceBack(), loadRequires(), RexxMethod::newMethodObject(), RoutineClass::newRoutineObject(), RexxActivity::reraiseException(), and resolveDotVariable().

◆ getStack()

RexxExpressionStack* RexxActivation::getStack ( )

inline

Definition at line 405 of file RexxActivation.hpp.

References stack.

Referenced by RexxVariableReference::drop(), RexxInstructionCall::trap(), and RexxVariableReference::upper().

◆ getStackFrames()

RexxArray * RexxActivation::getStackFrames ( bool skipFirst )

Generate the stack frames for the current context.

Returns: A list of the stackframes.

Definition at line 4694 of file RexxActivation.cpp.

References activity, and RexxActivity::generateStackFrames().

Referenced by RexxContext::getStackFrames().

◆ getStreams()

RexxDirectory * RexxActivation::getStreams ( )

Definition at line 1930 of file RexxActivation.cpp.

References RexxActivationBase::getPreviousStackFrame(), isProgramOrMethod(), RexxActivationBase::isRexxContext(), new_directory(), OREF_NULL, settings, and ActivationSettings::streams.

Referenced by resolveStream().

◆ getThreadLocal()

RexxDirectory * RexxActivation::getThreadLocal ( )

Returns: The directory of thread's local variables.

Definition at line 4597 of file RexxActivation.cpp.

References activity, and RexxActivity::getThreadLocal().

Referenced by rexxVariable().

◆ getTime()

RexxDateTime RexxActivation::getTime ( )

Definition at line 3185 of file RexxActivation.cpp.

References ActivationSettings::elapsed_time, SystemInterpreter::getCurrentTime(), RexxDateTime::getUTCBaseTime(), isElapsedTimerReset(), setElapsedTimerValid(), settings, ActivationSettings::timestamp, and RexxDateTime::valid.

◆ getTraceBack()

RexxString * RexxActivation::getTraceBack ( )

Get a traceback line for the current instruction.

Returns: The formatted string traceback.

Definition at line 3179 of file RexxActivation.cpp.

References current, formatTrace(), and getSourceObject().

Referenced by createStackFrame().

◆ getVariableDictionary()

RexxVariableDictionary* RexxActivation::getVariableDictionary ( )

inline

Definition at line 457 of file RexxActivation.hpp.

References RexxObject::getObjectVariables(), receiver, and scope.

Referenced by getReserveCount(), and RexxActivity::traceOutput().

◆ guardOff()

void RexxActivation::guardOff ( )

inline

Definition at line 199 of file RexxActivation.hpp.

References activity, object_scope, ActivationSettings::object_variables, RexxVariableDictionary::release(), SCOPE_RELEASED, SCOPE_RESERVED, and settings.

Referenced by RexxInstructionGuard::execute(), and termination().

◆ guardOn()

void RexxActivation::guardOn ( )

Definition at line 2052 of file RexxActivation.cpp.

References activity, RexxObject::getObjectVariables(), object_scope, ActivationSettings::object_variables, OREF_NULL, receiver, RexxVariableDictionary::reserve(), scope, SCOPE_RELEASED, SCOPE_RESERVED, and settings.

Referenced by RexxInstructionGuard::execute().

◆ guardWait()

void RexxActivation::guardWait ( )

Definition at line 3148 of file RexxActivation.cpp.

References activity, RexxActivity::guardWait(), object_scope, ActivationSettings::object_variables, RexxVariableDictionary::release(), RexxVariableDictionary::reserve(), SCOPE_RELEASED, SCOPE_RESERVED, and settings.

Referenced by RexxInstructionGuard::execute().

◆ halt()

bool RexxActivation::halt ( RexxString * description )

Halt the activation

Parameters

description The description for the halt condition (if any).

Returns: true if this halt was recognized, false if there is a previous halt condition still to be processed.

Definition at line 3923 of file RexxActivation.cpp.

References clause_boundary, ActivationSettings::flags, halt_condition, ActivationSettings::halt_description, and settings.

Referenced by RexxActivity::callHaltTestExit(), and RexxActivity::halt().

◆ handleNovalueEvent()

RexxObject * RexxActivation::handleNovalueEvent	(	RexxString *	name,
		RexxObject *	defaultValue,
		RexxVariable *	variable
	)

Process a NOVALUE event for a variable.

Parameters

name	The variable name triggering the event.
variable	The resolved variable object for the variable.

Returns: A value for that variable.

Definition at line 2464 of file RexxActivation.cpp.

References activity, RexxActivity::callNovalueExit(), novalueEnabled(), novalueHandler(), OREF_NULL, reportNovalue(), RexxVariable::set(), and TheNilObject.

Referenced by RexxParseVariable::evaluate(), and RexxStem::handleNovalue().

◆ hasActiveBlocks()

bool RexxActivation::hasActiveBlocks ( )

inline

Definition at line 382 of file RexxActivation.hpp.

References blockNest.

Referenced by RexxInstructionEnd::execute(), and RexxInstructionOtherwise::execute().

◆ implicitExit()

void RexxActivation::implicitExit ( )

inline

Definition at line 311 of file RexxActivation.hpp.

References activation_context, activity, RexxActivity::callTerminationExit(), execution_state, exitFrom(), INTERPRET, OREF_NULL, PROGRAM_LEVEL_CALL, RETURNED, and TOP_LEVEL_CALL.

Referenced by run().

◆ inDebug()

bool RexxActivation::inDebug ( )

inline

Definition at line 403 of file RexxActivation.hpp.

References debug_pause, ActivationSettings::flags, settings, and trace_debug.

Referenced by command(), and RexxInstructionTrace::execute().

◆ indent()

void RexxActivation::indent ( )

inline

Definition at line 384 of file RexxActivation.hpp.

References settings, and ActivationSettings::traceindent.

Referenced by addBlock(), RexxInstructionElse::execute(), RexxInstructionOtherwise::execute(), RexxInstructionThen::execute(), and RexxInstructionDo::reExecute().

◆ inMethod()

bool RexxActivation::inMethod ( )

inline

Definition at line 383 of file RexxActivation.hpp.

References activation_context, and METHODCALL.

Referenced by RexxInstructionExpose::execute(), RexxInstructionForward::execute(), RexxInstructionGuard::execute(), RexxInstructionReply::execute(), RexxInstructionUseStrict::executeNamedArguments(), and RexxInstructionUseStrict::executePositionalArguments().

◆ internalCall()

RexxObject * RexxActivation::internalCall	(	RexxString *	name,
		RexxInstruction *	target,
		RexxObject **	_arguments,
		size_t	_argcount,
		size_t	_named_argcount,
		ProtectedObject &	returnObject
	)

Process an internal function or subroutine call.

Parameters

name	The name of the target label.
target	The target instruction where we start executing (this is the label)
_argcount	The count of positional arguments
_stack	The context stack holding the arguments
returnObject	A holder for the return value

Returns: The return value object

Definition at line 3099 of file RexxActivation.cpp.

References activity, current, RexxInstruction::getLineNumber(), INTERNALCALL, new_integer(), ActivityManager::newActivation(), OREF_NULL, ActivationSettings::parent_code, RexxActivity::pushStackFrame(), receiver, run(), setLocalVariable(), settings, and VARIABLE_SIGL.

Referenced by RexxExpressionFunction::evaluate(), and RexxInstructionCall::execute().

◆ internalCallTrap()

RexxObject * RexxActivation::internalCallTrap	(	RexxString *	name,
		RexxInstruction *	target,
		RexxDirectory *	conditionObj,
		ProtectedObject &	resultObj
	)

Processing a call to an internal trap subroutine.

Parameters

name	The label name of the internal call.
target	The target instruction for the call (the label)
conditionObj	The associated condition object
resultObj	A holder for a result object

Returns: Any return result

Definition at line 3128 of file RexxActivation.cpp.

References activity, current, RexxInstruction::getLineNumber(), INTERNALCALL, new_integer(), ActivityManager::newActivation(), OREF_NULL, ActivationSettings::parent_code, RexxExpressionStack::push(), RexxActivity::pushStackFrame(), run(), setConditionObj(), setLocalVariable(), settings, stack, and VARIABLE_SIGL.

Referenced by RexxInstructionCall::trap().

◆ internalMethod()

bool RexxActivation::internalMethod ( )

◆ interpret()

void RexxActivation::interpret ( RexxString * codestring )

Definition at line 2567 of file RexxActivation.cpp.

References activity, argcount, arglist, arguments, RexxActivity::checkStackSpace(), code, current, ActivityManager::currentActivity, RexxInstruction::getLineNumber(), INTERPRET, RexxCode::interpret(), named_argcount, ActivityManager::newActivation(), OREF_NULL, RexxActivity::pushStackFrame(), and run().

Referenced by RexxInstructionInterpret::execute().

◆ isElapsedTimerReset()

bool RexxActivation::isElapsedTimerReset ( )

inline

Definition at line 464 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by getTime().

◆ isExternalTraceOn()

bool RexxActivation::isExternalTraceOn ( )

inline

Definition at line 459 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_on.

Referenced by processClauseBoundary().

◆ isForwarded()

bool RexxActivation::isForwarded ( )

inlinevirtual

Reimplemented from RexxActivationBase.

Definition at line 450 of file RexxActivation.hpp.

References ActivationSettings::flags, forwarded, and settings.

Referenced by RexxActivity::raiseException().

◆ isGuarded()

bool RexxActivation::isGuarded ( )

inline

Definition at line 451 of file RexxActivation.hpp.

References ActivationSettings::flags, guarded_method, and settings.

Referenced by getObjectVariables(), and run().

◆ isInternalCall()

bool RexxActivation::isInternalCall ( )

inline

Definition at line 212 of file RexxActivation.hpp.

References activation_context, and INTERNALCALL.

Referenced by checkTrapTable(), createStackFrame(), run(), and trapOff().

◆ isInternalLevelCall()

bool RexxActivation::isInternalLevelCall ( )

inline

Definition at line 218 of file RexxActivation.hpp.

References activation_context, and INTERNAL_LEVEL_CALL.

Referenced by cleanupLocalVariables(), external(), and getRandomSeed().

◆ isInterpret()

bool RexxActivation::isInterpret ( )

inline

Definition at line 211 of file RexxActivation.hpp.

References activation_context, and INTERPRET.

Referenced by createStackFrame(), getContextLine(), getContextLineNumber(), getEffectiveSourceObject(), getReceiver(), propagateNumericSettings(), returnFrom(), rexxVariable(), run(), setDigits(), setForm(), setFuzz(), signalTo(), trap(), and unwindTrap().

◆ isMethod()

bool RexxActivation::isMethod ( )

inline

Definition at line 213 of file RexxActivation.hpp.

References activation_context, and METHODCALL.

Referenced by createStackFrame(), formatSourcelessTraceLine(), isMethodOrRoutine(), and traceEntry().

◆ isMethodOrRoutine()

bool RexxActivation::isMethodOrRoutine ( )

inline

Definition at line 220 of file RexxActivation.hpp.

References isMethod(), and isRoutine().

Referenced by run().

◆ isObjectScopeLocked()

bool RexxActivation::isObjectScopeLocked ( )

inline

Definition at line 453 of file RexxActivation.hpp.

References object_scope, and SCOPE_RESERVED.

Referenced by RexxActivity::traceOutput().

◆ isProgram()

bool RexxActivation::isProgram ( )

inline

Definition at line 215 of file RexxActivation.hpp.

References activation_context, and PROGRAMCALL.

Referenced by createStackFrame().

◆ isProgramLevelCall()

bool RexxActivation::isProgramLevelCall ( )

inline

Definition at line 217 of file RexxActivation.hpp.

References activation_context, and PROGRAM_LEVEL_CALL.

Referenced by exitFrom(), raiseExit(), returnFrom(), and run().

◆ isProgramOrMethod()

bool RexxActivation::isProgramOrMethod ( )

inline

Definition at line 219 of file RexxActivation.hpp.

References activation_context, and PROGRAM_OR_METHOD.

Referenced by closeStreams(), and getStreams().

◆ isRexxContext()

bool RexxActivation::isRexxContext ( )

virtual

Indicate whether this activation is a Rexx context or not.

Returns: true if this is a Rexx context, false otherwise.

Reimplemented from RexxActivationBase.

Definition at line 2233 of file RexxActivation.cpp.

◆ isRoutine()

bool RexxActivation::isRoutine ( )

inline

Definition at line 214 of file RexxActivation.hpp.

References activation_context, and EXTERNALCALL.

Referenced by createStackFrame(), formatSourcelessTraceLine(), isMethodOrRoutine(), and traceEntry().

◆ isTopLevel()

bool RexxActivation::isTopLevel ( )

inline

Definition at line 449 of file RexxActivation.hpp.

References activation_context, and TOP_LEVEL_CALL.

Referenced by exitFrom().

◆ isTopLevelCall()

bool RexxActivation::isTopLevelCall ( )

inline

Definition at line 216 of file RexxActivation.hpp.

References activation_context, and TOP_LEVEL_CALL.

Referenced by exitFrom(), popEnvironment(), pushEnvironment(), raiseExit(), and run().

◆ iterate()

void RexxActivation::iterate ( RexxString * name )

Definition at line 1244 of file RexxActivation.cpp.

References Error_Invalid_leave_iterate, Error_Invalid_leave_iterate_name, Error_Invalid_leave_iteratevar, RexxDoBlock::getIndent(), RexxDoBlock::getParent(), RexxBlockInstruction::isLabel(), RexxBlockInstruction::isLoop(), OREF_NULL, popBlock(), removeBlock(), reportException(), setIndent(), stack, and topBlock().

Referenced by RexxInstructionLeave::execute().

◆ leaveLoop()

void RexxActivation::leaveLoop ( RexxString * name )

Definition at line 1296 of file RexxActivation.cpp.

References Error_Invalid_leave_leave, Error_Invalid_leave_leavevar, RexxDoBlock::getParent(), RexxBlockInstruction::isLabel(), RexxBlockInstruction::isLoop(), OREF_NULL, popBlock(), removeBlock(), reportException(), RexxBlockInstruction::terminate(), and topBlock().

Referenced by RexxInstructionLeave::execute().

◆ live()

void RexxActivation::live ( size_t liveMark )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 1065 of file RexxActivation.cpp.

◆ liveGeneral()

void RexxActivation::liveGeneral ( int reason )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 1125 of file RexxActivation.cpp.

◆ loadLibrary()

void RexxActivation::loadLibrary	(	RexxString *	target,
		RexxInstruction *	instruction
	)

Load a package defined by a ::REQUIRES name LIBRARY directive.

Parameters

target	The name of the package.
instruction	The ::REQUIRES directive being loaded.

Definition at line 3078 of file RexxActivation.cpp.

References current, and PackageManager::getLibrary().

Referenced by LibraryDirective::install().

◆ loadRequires()

PackageClass * RexxActivation::loadRequires	(	RexxString *	target,
		RexxInstruction *	instruction
	)

Load a ::REQUIRES directive when the source file is first invoked.

Parameters

target	The name of the ::REQUIRES
instruction	The directive instruction being processed.

Definition at line 3060 of file RexxActivation.cpp.

References activity, current, getSourceObject(), and RexxSource::loadRequires().

Referenced by RequiresDirective::install().

◆ local()

RexxDirectory* RexxActivation::local ( )

◆ localCompoundVariableExists()

bool RexxActivation::localCompoundVariableExists	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount
	)

Definition at line 4495 of file RexxActivation.cpp.

References RexxStem::compoundVariableExists(), and getLocalStem().

Referenced by RexxCompoundVariable::exists().

◆ localStemVariableExists()

bool RexxActivation::localStemVariableExists	(	RexxString *	stemName,
		size_t	index
	)

inline

Definition at line 543 of file RexxActivation.hpp.

References RexxLocalVariables::find(), ActivationSettings::local_variables, OREF_NULL, and settings.

Referenced by RexxStemVariable::exists().

◆ localVariableExists()

bool RexxActivation::localVariableExists	(	RexxString *	name,
		size_t	index
	)

inline

Definition at line 551 of file RexxActivation.hpp.

References RexxLocalVariables::find(), RexxVariable::getVariableValue(), ActivationSettings::local_variables, OREF_NULL, and settings.

Referenced by RexxParseVariable::exists().

◆ mergeTraps()

void RexxActivation::mergeTraps	(	RexxQueue *	source_condition_queue,
		RexxQueue *	source_handler_queue
	)

Definition at line 2493 of file RexxActivation.cpp.

References RexxList::addLast(), condition_queue, RexxList::getSize(), handler_queue, OREF_NULL, pending_count, and RexxQueue::pullRexx().

Referenced by run(), trap(), and unwindTrap().

◆ newDo()

void RexxActivation::newDo ( RexxDoBlock * block )

inline

Definition at line 379 of file RexxActivation.hpp.

References blockNest, pushBlock(), settings, and ActivationSettings::traceindent.

Referenced by RexxInstructionDo::execute(), and RexxInstructionSelect::execute().

◆ newLocalVariable()

RexxVariable* RexxActivation::newLocalVariable ( RexxString * name )

inline

Definition at line 599 of file RexxActivation.hpp.

References RexxVariable::getNext(), memoryObject, new_variable(), OREF_NULL, RexxVariable::reset(), RexxVariable::setCreator(), and RexxMemory::variableCache.

Referenced by RexxLocalVariables::lookupStemVariable(), and RexxLocalVariables::lookupVariable().

◆ novalueEnabled()

bool RexxActivation::novalueEnabled ( )

inline

Definition at line 591 of file RexxActivation.hpp.

References RexxLocalVariables::getNovalue(), ActivationSettings::local_variables, and settings.

Referenced by handleNovalueEvent().

◆ novalueHandler()

RexxObject * RexxActivation::novalueHandler ( RexxString * name )

Definition at line 4409 of file RexxActivation.cpp.

References getLocalEnvironment(), OREF_NULL, RexxObject::sendMessage(), and TheNilObject.

Referenced by handleNovalueEvent().

◆ operator delete() [1/2]

void RexxActivation::operator delete ( void * )

inline

Definition at line 169 of file RexxActivation.hpp.

◆ operator delete() [2/2]

void RexxActivation::operator delete	(	void *	,
		void *
	)

inline

Definition at line 170 of file RexxActivation.hpp.

◆ operator new() [1/2]

void* RexxActivation::operator new	(	size_t	size,
		void *	ptr
	)

inline

Definition at line 168 of file RexxActivation.hpp.

◆ operator new() [2/2]

void * RexxActivation::operator new ( size_t size )

Definition at line 134 of file RexxActivation.cpp.

References new_object(), and T_Activation.

◆ pauseCommand()

void RexxActivation::pauseCommand ( )

inline

Definition at line 445 of file RexxActivation.hpp.

References debugPause(), ActivationSettings::flags, settings, trace_commands, and trace_debug.

◆ pauseInstruction()

void RexxActivation::pauseInstruction ( )

inline

Definition at line 442 of file RexxActivation.hpp.

References debugPause(), ActivationSettings::flags, settings, trace_all, and trace_debug.

◆ pauseLabel()

void RexxActivation::pauseLabel ( )

inline

Definition at line 444 of file RexxActivation.hpp.

References debugPause(), ActivationSettings::flags, settings, trace_debug, and trace_labels.

Referenced by RexxInstructionLabel::execute(), and run().

◆ popBlock()

void RexxActivation::popBlock ( )

inline

Definition at line 375 of file RexxActivation.hpp.

References dostack, RexxDoBlock::getPrevious(), and RexxInternalObject::setHasNoReferences().

Referenced by iterate(), leaveLoop(), RexxInstructionDo::reExecute(), and terminateBlock().

◆ popControl()

RexxObject* RexxActivation::popControl ( )

◆ popEnvironment()

RexxObject * RexxActivation::popEnvironment ( )

Definition at line 4356 of file RexxActivation.cpp.

References environmentList, isTopLevelCall(), parent, popEnvironment(), RexxList::removeFirst(), and TheNilObject.

Referenced by popEnvironment(), and SystemInterpreter::popEnvironment().

◆ procedureExpose()

void RexxActivation::procedureExpose	(	RexxVariableBase **	variables,
		size_t	count
	)

Definition at line 1356 of file RexxActivation.cpp.

References activity, RexxActivity::allocateLocalVariableFrame(), Error_Unexpected_procedure_call, ActivationSettings::flags, ActivationSettings::local_variables, parent, RexxLocalVariables::procedure(), procedure_valid, RexxVariableBase::procedureExpose(), reportException(), settings, and stack.

Referenced by RexxInstructionProcedure::execute().

◆ processClauseBoundary()

void RexxActivation::processClauseBoundary ( )

◆ processTraceSetting()

size_t RexxActivation::processTraceSetting ( size_t traceSetting )

static

Process a trace setting and reduce it to the component flag settings that can be used to set defaults.

Parameters

traceSetting The input trace setting.

Returns: The set of flags that will be set in the debug flags when trace setting change.

Definition at line 998 of file RexxActivation.cpp.

References RexxSource::DEBUG_IGNORE, RexxSource::DEBUG_OFF, RexxSource::DEBUG_ON, RexxSource::DEBUG_TOGGLE, trace_all, RexxSource::TRACE_ALL, trace_commands, RexxSource::TRACE_COMMANDS, trace_debug, TRACE_DEBUG_MASK, trace_errors, RexxSource::TRACE_ERRORS, trace_failures, RexxSource::TRACE_FAILURES, RexxSource::TRACE_IGNORE, trace_intermediates, RexxSource::TRACE_INTERMEDIATES, trace_labels, RexxSource::TRACE_LABELS, RexxSource::TRACE_NORMAL, trace_off, RexxSource::TRACE_OFF, trace_results, RexxSource::TRACE_RESULTS, RexxSource::TRACE_SETTING_MASK, and traceSetting().

Referenced by RexxSource::parseTraceSetting().

◆ processTraps()

void RexxActivation::processTraps ( )

Definition at line 788 of file RexxActivation.cpp.

References RexxList::addLast(), RexxDirectory::at(), condition_queue, RexxArray::get(), handler_queue, OREF_NULL, pending_count, RexxQueue::pullRexx(), setLocalVariable(), trap(), trapState(), and VARIABLE_RC.

Referenced by processClauseBoundary(), and run().

◆ propagateExit()

void RexxActivation::propagateExit ( RexxObject * )

◆ propagateNumericSettings() [1/2]

bool RexxActivation::propagateNumericSettings ( )

Definition at line 2097 of file RexxActivation.cpp.

References ActivationSettings::propagateNumericSettings, and settings.

Referenced by RexxInstructionNumeric::execute(), RexxContext::getDigitsPropagate(), and propagateNumericSettings().

◆ propagateNumericSettings() [2/2]

void RexxActivation::propagateNumericSettings ( bool status )

Definition at line 2177 of file RexxActivation.cpp.

References isInterpret(), parent, ActivationSettings::propagateNumericSettings, propagateNumericSettings(), and settings.

◆ pushBlock()

void RexxActivation::pushBlock ( RexxDoBlock * block )

inline

Definition at line 374 of file RexxActivation.hpp.

References dostack, and RexxDoBlock::setPrevious().

Referenced by newDo().

◆ pushControl()

void RexxActivation::pushControl ( RexxObject * )

◆ pushEnvironment()

void RexxActivation::pushEnvironment ( RexxObject * environment )

Definition at line 4331 of file RexxActivation.cpp.

References RexxList::addFirst(), environmentList, isTopLevelCall(), new_list(), parent, and pushEnvironment().

Referenced by SystemInterpreter::pushEnvironment(), and pushEnvironment().

◆ putLocalVariable()

void RexxActivation::putLocalVariable	(	RexxVariable *	variable,
		size_t	index
	)

inline

Definition at line 559 of file RexxActivation.hpp.

References ActivationSettings::local_variables, RexxLocalVariables::putVariable(), and settings.

Referenced by RexxStemVariable::expose(), RexxParseVariable::expose(), RexxStemVariable::procedureExpose(), and RexxParseVariable::procedureExpose().

◆ putSettings()

void RexxActivation::putSettings ( ActivationSettings & s )

inline

Definition at line 396 of file RexxActivation.hpp.

References settings.

Referenced by RexxActivation(), and unwindTrap().

◆ raise()

void RexxActivation::raise	(	RexxString *	condition,
		RexxObject *	rc,
		RexxString *	description,
		RexxObject *	additional,
		RexxObject *	resultObj,
		RexxDirectory *	conditionobj
	)

◆ raiseExit()

void RexxActivation::raiseExit	(	RexxString *	condition,
		RexxObject *	rc,
		RexxString *	description,
		RexxObject *	additional,
		RexxObject *	resultObj,
		RexxDirectory *	conditionobj
	)

Definition at line 1669 of file RexxActivation.cpp.

References activity, RexxActivity::callTerminationExit(), exitFrom(), isProgramLevelCall(), isTopLevelCall(), OREF_NULL, parent, RexxActivity::popStackFrame(), raiseExit(), and termination().

Referenced by RexxInstructionRaise::execute(), and raiseExit().

◆ random()

RexxInteger * RexxActivation::random	(	RexxInteger *	randmin,
		RexxInteger *	randmax,
		RexxInteger *	randseed
	)

Definition at line 3288 of file RexxActivation.cpp.

References DEFAULT_MAX, DEFAULT_MIN, Error_Incorrect_call_random, Error_Incorrect_call_random_range, getRandomSeed(), RexxInteger::getValue(), MAX_DIFFERENCE, new_integer(), OREF_NULL, reportException(), and work.

◆ removeBlock()

void RexxActivation::removeBlock ( )

inline

Definition at line 380 of file RexxActivation.hpp.

References blockNest, and unindent().

Referenced by RexxInstructionDo::execute(), RexxInstructionEnd::execute(), iterate(), leaveLoop(), and RexxInstructionDo::reExecute().

◆ reply()

void RexxActivation::reply ( RexxObject * resultObj )

Definition at line 1185 of file RexxActivation.cpp.

References Error_Execution_reply, execution_state, ActivationSettings::flags, next, OREF_NULL, REPLIED, reply_issued, reportException(), result, and settings.

Referenced by RexxInstructionReply::execute().

◆ resetElapsed()

void RexxActivation::resetElapsed ( )

Definition at line 3233 of file RexxActivation.cpp.

References setElapsedTimerInvalid().

◆ resolveDotVariable()

RexxObject * RexxActivation::resolveDotVariable ( RexxString * name )

Resolve a class in this activation's context.

Parameters

name	The name to resolve.

Returns: The resolved class, or OREF_NULL if not found.

Definition at line 3036 of file RexxActivation.cpp.

References activation_context, RexxSource::findClass(), getSourceObject(), INTERPRET, parent, and resolveDotVariable().

Referenced by RexxDotVariable::evaluate(), RexxDotVariable::getValue(), and resolveDotVariable().

◆ resolveProgramName()

RexxString * RexxActivation::resolveProgramName ( RexxString * name )

This is resolved in the context of the calling program.

Parameters

name	The name to resolve.

Returns: The fully resolved program name, or OREF_NULL if this can't be located.

Definition at line 3004 of file RexxActivation.cpp.

References activity, code, and RexxCode::resolveProgramName().

Referenced by callExternalRexx().

◆ resolveStream()

RexxObject * RexxActivation::resolveStream	(	RexxString *	name,
		bool	input,
		RexxString **	fullName,
		bool *	added
	)

Resolve a stream name for a BIF call.

Parameters

name	The name of the stream.
stack	The expression stack.
input	The input/output flag.
fullName	The returned full name of the stream.
added	A flag indicating we added this.

Returns: The backing stream object for the name.

Definition at line 1846 of file RexxActivation.cpp.

References RexxDirectory::at(), SecurityManager::checkStreamAccess(), RexxString::getBLength(), getEffectiveSecurityManager(), getLocalEnvironment(), getStreams(), OREF_NULL, RexxDirectory::put(), SystemInterpreter::qualifyFileSystemName(), RexxObject::sendMessage(), RexxString::strCaselessCompare(), and TheEnvironment.

◆ retriever()

RexxVariableBase* RexxActivation::retriever ( RexxString * )

◆ returnFrom()

void RexxActivation::returnFrom ( RexxObject * result )

Definition at line 1205 of file RexxActivation.cpp.

References activity, RexxActivity::callTerminationExit(), debug_bypass, Error_Execution_reply_return, execution_state, ActivationSettings::flags, isInterpret(), isProgramLevelCall(), next, OREF_NULL, parent, reply_issued, reportException(), result, RETURNED, returnFrom(), settings, and trace_debug.

Referenced by RexxInstructionReturn::execute(), raise(), and returnFrom().

◆ rexxVariable()

RexxObject * RexxActivation::rexxVariable ( RexxString * name )

◆ run() [1/2]

RexxObject* RexxActivation::run	(	RexxArray *	_arguments,
		RexxObject **	_arglist,
		size_t	_argcount,
		size_t	_named_argcount,
		ProtectedObject &	_result
	)

inline

Definition at line 249 of file RexxActivation.hpp.

References OREF_NULL, and run().

◆ run() [2/2]

RexxObject * RexxActivation::run	(	RexxObject *	_receiver,
		RexxString *	msgname,
		RexxArray *	_arguments,
		RexxObject **	_arglist,
		size_t	_argcount,
		size_t	_named_argcount,
		RexxInstruction *	start,
		ProtectedObject &	resultObj
	)

Definition at line 484 of file RexxActivation.cpp.

Referenced by RexxCode::call(), debugInterpret(), dispatch(), internalCall(), internalCallTrap(), interpret(), RexxCode::run(), and run().

◆ senderActivation()

RexxActivation * RexxActivation::senderActivation ( )

Definition at line 2552 of file RexxActivation.cpp.

References RexxActivationBase::getPreviousStackFrame(), isOfClass, and OREF_NULL.

Referenced by getParentContextObject(), and raise().

◆ setAddress()

void RexxActivation::setAddress ( RexxString * address )

Definition at line 2003 of file RexxActivation.cpp.

References ActivationSettings::alternate_env, ActivationSettings::current_env, and settings.

Referenced by RexxInstructionAddress::execute().

◆ setArguments()

void RexxActivation::setArguments	(	RexxArray *	positionalArguments,
		RexxDirectory *	namedArguments
	)

Store user-redefined arguments.

Definition at line 4703 of file RexxActivation.cpp.

References RexxDirectory::appendAllIndexesItemsTo(), argcount, arglist, arguments, RexxArray::copy(), RexxArray::data(), named_argcount, OREF_NULL, RexxArray::size(), and TheNilObject.

Referenced by RexxContext::setArgs().

◆ setCallType()

void RexxActivation::setCallType ( RexxString * type )

inline

Definition at line 373 of file RexxActivation.hpp.

References ActivationSettings::calltype, settings, and type.

◆ setConditionObj()

void RexxActivation::setConditionObj ( RexxDirectory * condition )

inline

Definition at line 399 of file RexxActivation.hpp.

References RexxSource::condition(), ActivationSettings::conditionObj, and settings.

Referenced by internalCallTrap(), and RexxInstructionSignal::trap().

◆ setCurrent()

void RexxActivation::setCurrent ( RexxInstruction * v )

inline

Definition at line 402 of file RexxActivation.hpp.

References current.

Referenced by ClassDirective::install(), and ExtensionDirective::install().

◆ setDefaultAddress()

void RexxActivation::setDefaultAddress ( RexxString * address )

Definition at line 2016 of file RexxActivation.cpp.

References ActivationSettings::alternate_env, ActivationSettings::current_env, and settings.

Referenced by RexxActivation().

◆ setDigits() [1/2]

void RexxActivation::setDigits ( )

Set the digits setting to the package-defined default

Definition at line 2124 of file RexxActivation.cpp.

References RexxSource::getDigits(), and sourceObject.

◆ setDigits() [2/2]

void RexxActivation::setDigits ( size_t digitsVal )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2129 of file RexxActivation.cpp.

References NumericSettings::digits, isInterpret(), ActivationSettings::numericSettings, parent, setDigits(), and settings.

Referenced by RexxInstructionNumeric::execute(), setDigits(), and RexxNativeActivation::setDigits().

◆ setElapsedTimerInvalid()

void RexxActivation::setElapsedTimerInvalid ( )

inline

Definition at line 465 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by resetElapsed().

◆ setElapsedTimerValid()

void RexxActivation::setElapsedTimerValid ( )

inline

Definition at line 466 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by getTime().

◆ setExternalTraceOff()

void RexxActivation::setExternalTraceOff ( )

inline

Definition at line 461 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_on.

Referenced by processClauseBoundary().

◆ setExternalTraceOn()

void RexxActivation::setExternalTraceOn ( )

inline

Definition at line 460 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_on.

Referenced by processClauseBoundary().

◆ setForm() [1/2]

void RexxActivation::setForm ( )

Set the form setting to the package-defined default

Definition at line 2160 of file RexxActivation.cpp.

References RexxSource::getForm(), and sourceObject.

◆ setForm() [2/2]

void RexxActivation::setForm ( bool formVal )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2167 of file RexxActivation.cpp.

References NumericSettings::form, isInterpret(), ActivationSettings::numericSettings, parent, setForm(), and settings.

Referenced by RexxInstructionNumeric::execute(), setForm(), and RexxNativeActivation::setForm().

◆ setFuzz() [1/2]

void RexxActivation::setFuzz ( )

Set the fuzz setting to the package-defined default

Definition at line 2141 of file RexxActivation.cpp.

References RexxSource::getFuzz(), and sourceObject.

◆ setFuzz() [2/2]

void RexxActivation::setFuzz ( size_t fuzzVal )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2148 of file RexxActivation.cpp.

References NumericSettings::fuzz, isInterpret(), ActivationSettings::numericSettings, parent, setFuzz(), and settings.

Referenced by RexxInstructionNumeric::execute(), setFuzz(), and RexxNativeActivation::setFuzz().

◆ setGuarded()

void RexxActivation::setGuarded ( )

inline

Definition at line 452 of file RexxActivation.hpp.

References ActivationSettings::flags, guarded_method, and settings.

Referenced by RexxActivation().

◆ setIndent()

void RexxActivation::setIndent ( size_t v )

inline

Definition at line 386 of file RexxActivation.hpp.

References settings, and ActivationSettings::traceindent.

Referenced by RexxInstructionEnd::execute(), and iterate().

◆ setLocalCompoundVariable()

void RexxActivation::setLocalCompoundVariable	(	RexxString *	stemName,
		size_t	index,
		RexxObject **	tail,
		size_t	tailCount,
		RexxObject *	value
	)

Definition at line 4523 of file RexxActivation.cpp.

References getLocalStem(), and RexxStem::setCompoundVariable().

Referenced by RexxCompoundVariable::set().

◆ setLocalVariable()

void RexxActivation::setLocalVariable	(	RexxString *	name,
		size_t	index,
		RexxObject *	value
	)

inline

Definition at line 569 of file RexxActivation.hpp.

References getLocalVariable(), and RexxVariable::set().

Referenced by RexxParseVariable::assign(), command(), RexxInstructionCall::execute(), RexxInstructionCommand::execute(), RexxInstructionForward::execute(), RexxInstructionMessage::execute(), internalCall(), internalCallTrap(), processTraps(), run(), RexxParseVariable::set(), and signalTo().

◆ setLocalVariableDictionary()

void RexxActivation::setLocalVariableDictionary ( RexxVariableDictionary * dict )

inline

Definition at line 643 of file RexxActivation.hpp.

References ActivationSettings::local_variables, RexxLocalVariables::setDictionary(), and settings.

Referenced by cleanupLocalVariables().

◆ setNext()

void RexxActivation::setNext ( RexxInstruction * v )

inline

Definition at line 401 of file RexxActivation.hpp.

References next.

Referenced by RexxInstructionDo::execute(), RexxInstructionEndIf::execute(), RexxInstructionIf::execute(), RexxInstructionDo::reExecute(), RexxInstructionDo::terminate(), and RexxInstructionSelect::terminate().

◆ setObjNotify()

void RexxActivation::setObjNotify ( RexxMessage * notify )

virtual

Reimplemented from RexxActivationBase.

Definition at line 4321 of file RexxActivation.cpp.

References objnotify.

◆ setReturnStatus()

void RexxActivation::setReturnStatus ( int status )

Set the return status flag for an activation context.

Parameters

status The new status value.

Definition at line 4252 of file RexxActivation.cpp.

References ActivationSettings::flags, ActivationSettings::return_status, return_status_set, and settings.

Referenced by command().

◆ setTrace() [1/2]

void RexxActivation::setTrace	(	RexxString *	setting,
		bool	externalTrace = `false`,
		size_t	depth = `0`
	)

Set the trace using a dynamically evaluated string.

Parameters

setting The new trace setting.

Definition at line 883 of file RexxActivation.cpp.

References Error_Invalid_trace_trace, ActivationSettings::externalTraceDepth, ActivationSettings::externalTraceFlags, ActivationSettings::externalTraceOption, new_string(), RexxSource::parseTraceSetting(), reportException(), settings, and setTrace().

◆ setTrace() [2/2]

void RexxActivation::setTrace	(	size_t	traceOption,
		size_t	traceFlags
	)

Set a new trace setting for the context.

Parameters

traceOption The new trace setting option. This includes the setting option and any debug flag options, ANDed together.

Definition at line 912 of file RexxActivation.cpp.

References clearTraceSettings(), debug_bypass, DEBUG_ON, RexxSource::DEBUG_ON, debug_pause, debug_prompt_issued, RexxSource::DEBUG_TOGGLE, ActivationSettings::flags, ActivationSettings::intermediate_trace, settings, trace_debug, trace_flags, trace_intermediates, ActivationSettings::trace_skip, trace_suppress, and ActivationSettings::traceOption.

Referenced by enableExternalTrace(), RexxInstructionTrace::execute(), externalTraceOn(), processClauseBoundary(), RexxActivation(), and setTrace().

◆ signalTo()

void RexxActivation::signalTo ( RexxInstruction * target )

Definition at line 1965 of file RexxActivation.cpp.

References blockNest, current, dostack, execution_state, RexxInstruction::getLineNumber(), isInterpret(), new_integer(), next, OREF_NULL, parent, RETURNED, setLocalVariable(), settings, signalTo(), ActivationSettings::traceindent, and VARIABLE_SIGL.

Referenced by RexxInstructionSignal::execute(), signalTo(), signalValue(), and RexxInstructionSignal::trap().

◆ signalValue()

void RexxActivation::signalValue ( RexxString * name )

Definition at line 2029 of file RexxActivation.cpp.

References RexxDirectory::at(), Error_Label_not_found_name, getLabels(), OREF_NULL, reportException(), and signalTo().

Referenced by RexxInstructionSignal::execute().

◆ sourceString()

RexxString * RexxActivation::sourceString ( )

Definition at line 4275 of file RexxActivation.cpp.

References ActivationSettings::calltype, SystemInterpreter::getSourceString(), and settings.

Referenced by RexxInstructionParse::execute(), traceSourceString(), and RexxNativeActivation::variablePoolFetchPrivate().

◆ terminateBlock() [1/2]

void RexxActivation::terminateBlock ( )

inline

Definition at line 378 of file RexxActivation.hpp.

References blockNest, dostack, RexxDoBlock::getIndent(), popBlock(), settings, and ActivationSettings::traceindent.

◆ terminateBlock() [2/2]

void RexxActivation::terminateBlock ( size_t _indent )

inline

Definition at line 377 of file RexxActivation.hpp.

References blockNest, popBlock(), settings, and ActivationSettings::traceindent.

Referenced by RexxInstructionEndIf::execute(), RexxInstructionEnd::execute(), RexxInstructionDo::terminate(), and RexxInstructionSelect::terminate().

◆ termination()

void RexxActivation::termination ( )

virtual

Reimplemented from RexxActivationBase.

Definition at line 1556 of file RexxActivation.cpp.

References activity, cleanupLocalVariables(), closeStreams(), contextObject, RexxContext::detach(), environmentList, RexxExpressionStack::getFrame(), RexxList::getSize(), guardOff(), RexxList::lastItem(), OREF_NULL, RexxActivity::releaseStackFrame(), SystemInterpreter::restoreEnvironment(), and stack.

Referenced by exitFrom(), forward(), raise(), raiseExit(), and run().

◆ toggleAddress()

void RexxActivation::toggleAddress ( )

Definition at line 1991 of file RexxActivation.cpp.

References ActivationSettings::alternate_env, ActivationSettings::current_env, and settings.

Referenced by RexxInstructionAddress::execute().

◆ topBlock()

RexxDoBlock* RexxActivation::topBlock ( )

inline

Definition at line 376 of file RexxActivation.hpp.

References dostack.

Referenced by RexxInstructionEnd::execute(), iterate(), and leaveLoop().

◆ traceAssignment()

void RexxActivation::traceAssignment	(	RexxString *	n,
		RexxObject *	v,
		bool	quoteValue = `true`
	)

inline

Definition at line 426 of file RexxActivation.hpp.

References ASSIGNMENT_MARKER, ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_ASSIGNMENT, and traceTaggedValue().

Referenced by RexxExpressionMessage::assign(), RexxStemVariable::assign(), RexxParseVariable::assign(), RexxStemVariable::drop(), and RexxParseVariable::drop().

◆ traceClause()

void RexxActivation::traceClause	(	RexxInstruction *	clause,
		int	prefix
	)

Definition at line 4058 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, formatTrace(), RexxCode::getSourceObject(), RexxCode::isTraceable(), line, OREF_NULL, settings, source_traced, trace_debug, trace_suppress, RexxActivity::traceOutput(), and traceSourceString().

Referenced by command(), traceCommand(), traceInstruction(), and traceLabel().

◆ traceCommand()

void RexxActivation::traceCommand ( RexxInstruction * v )

inline

Definition at line 439 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, trace_commands, TRACE_PREFIX_CLAUSE, and traceClause().

Referenced by RexxInstructionCommand::execute().

◆ traceCompound()

void RexxActivation::traceCompound	(	RexxString *	stemVar,
		RexxObject **	tails,
		size_t	tailCount,
		RexxObject *	value
	)

inline

Definition at line 430 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_VARIABLE, traceCompoundValue(), and VALUE_MARKER.

Referenced by evaluateLocalCompoundVariable().

◆ traceCompoundAssignment()

void RexxActivation::traceCompoundAssignment	(	RexxString *	stemVar,
		RexxObject **	tails,
		size_t	tailCount,
		RexxObject *	value,
		bool	quoteValue = `true`
	)

inline

Definition at line 431 of file RexxActivation.hpp.

References ASSIGNMENT_MARKER, ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_ASSIGNMENT, and traceCompoundValue().

Referenced by assignLocalCompoundVariable(), and dropLocalCompoundVariable().

◆ traceCompoundName() [1/2]

void RexxActivation::traceCompoundName	(	RexxString *	stemVar,
		RexxObject **	tails,
		size_t	tailCount,
		RexxCompoundTail *	tail
	)

inline

Definition at line 428 of file RexxActivation.hpp.

References RexxCompoundTail::createCompoundName(), ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_COMPOUND, traceCompoundValue(), and VALUE_MARKER.

Referenced by assignLocalCompoundVariable(), dropLocalCompoundVariable(), evaluateLocalCompoundVariable(), RexxCompoundVariable::expose(), and RexxCompoundVariable::procedureExpose().

◆ traceCompoundName() [2/2]

void RexxActivation::traceCompoundName	(	RexxString *	stemVar,
		RexxObject **	tails,
		size_t	tailCount,
		RexxString *	tail
	)

inline

Definition at line 429 of file RexxActivation.hpp.

References RexxString::concat(), ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_COMPOUND, traceCompoundValue(), and VALUE_MARKER.

◆ traceCompoundValue() [1/2]

void RexxActivation::traceCompoundValue	(	int	prefix,
		RexxString *	stemName,
		RexxObject **	tails,
		size_t	tailCount,
		const char *	marker,
		RexxObject *	value,
		bool	quoteValue = `true`
	)

Trace a compound variable entry that's of the form 'tag => "value"'.

Parameters

prefix	The trace prefix tag to use.
stem	The stem name of the compound.
tails	The array of tail elements (unresolved).
tailCount	The count of tail elements.
value	The associated trace value. @quoteValue Indicates whether the value should be quoted or not.

Definition at line 3681 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxString::getBLength(), RexxCompoundTail::getLength(), RexxCompoundTail::getTail(), INDENT_SPACING, RexxCode::isTraceable(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putCharB(), raw_string(), RexxString::set(), settings, RexxObject::stringValue(), TRACE_OVERHEAD, trace_prefix_table, trace_suppress, ActivationSettings::traceindent, and RexxActivity::traceOutput().

◆ traceCompoundValue() [2/2]

void RexxActivation::traceCompoundValue	(	int	prefix,
		RexxString *	stemName,
		RexxObject **	tails,
		size_t	tailCount,
		RexxCompoundTail *	tail
	)

Trace a compound variable entry that's of the form 'tag => "value"'.

Parameters

prefix	The trace prefix tag to use.
stem	The stem name of the compound.
tails	The array of tail elements (unresolved).
tailCount	The count of tail elements.
value	The resolved tail element

Definition at line 3663 of file RexxActivation.cpp.

References RexxCompoundTail::createCompoundName(), TRACE_PREFIX_COMPOUND, and VALUE_MARKER.

Referenced by traceCompound(), traceCompoundAssignment(), and traceCompoundName().

◆ traceDotVariable()

void RexxActivation::traceDotVariable	(	RexxString *	n,
		RexxObject *	v
	)

inline

Definition at line 416 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_DOTVARIABLE, traceTaggedValue(), and VALUE_MARKER.

Referenced by RexxDotVariable::evaluate().

◆ traceEntry()

void RexxActivation::traceEntry ( )

Trace program entry for a method or routine

Definition at line 3402 of file RexxActivation.cpp.

References activity, RexxActivity::buildMessage(), ActivationSettings::flags, RexxString::getBLength(), RexxActivationBase::getExecutable(), RexxClass::getId(), getMessageName(), getPackage(), RexxString::getStringData(), INSTRUCTION_OVERHEAD, isMethod(), isRoutine(), Message_Translations_method_invocation, Message_Translations_routine_invocation, new_array(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), raw_string(), RexxObject::requestString(), scope, RexxString::set(), settings, source_traced, TheNilObject, TRACE_PREFIX_INVOCATION, trace_prefix_table, and RexxActivity::traceOutput().

Referenced by run().

◆ traceFunction()

void RexxActivation::traceFunction	(	RexxString *	n,
		RexxObject *	v
	)

inline

Definition at line 418 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_FUNCTION, traceTaggedValue(), and VALUE_MARKER.

Referenced by RexxExpressionFunction::evaluate().

◆ traceInstruction()

void RexxActivation::traceInstruction ( RexxInstruction * v )

inline

Definition at line 436 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, trace_all, TRACE_PREFIX_CLAUSE, and traceClause().

◆ traceIntermediate()

void RexxActivation::traceIntermediate	(	RexxObject *	v,
		int	p
	)

inline

Definition at line 413 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, and traceValue().

Referenced by RexxExpressionMessage::assign(), RexxSourceLiteral::evaluate(), RexxInteger::evaluate(), RexxNumberString::evaluate(), RexxString::evaluate(), RexxExpressionFunction::evaluate(), RexxExpressionList::evaluate(), RexxExpressionMessage::evaluate(), RexxInstructionCall::execute(), RexxInstructionMessage::execute(), and RexxTrigger::parse().

◆ traceLabel()

void RexxActivation::traceLabel ( RexxInstruction * v )

inline

Definition at line 437 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, trace_labels, TRACE_PREFIX_CLAUSE, and traceClause().

Referenced by RexxInstructionLabel::execute().

◆ traceMessage()

void RexxActivation::traceMessage	(	RexxString *	n,
		RexxObject *	v
	)

inline

Definition at line 420 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_MESSAGE, traceTaggedValue(), and VALUE_MARKER.

Referenced by RexxExpressionMessage::evaluate().

◆ traceOperator()

void RexxActivation::traceOperator	(	const char *	n,
		RexxObject *	v
	)

inline

Definition at line 422 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_OPERATOR, and traceOperatorValue().

Referenced by RexxBinaryOperator::evaluate().

◆ traceOperatorValue()

void RexxActivation::traceOperatorValue	(	int	prefix,
		const char *	tag,
		RexxObject *	value
	)

Trace an entry that's of the form 'tag => "value"'.

Parameters

prefix	The trace prefix tag to use.
tagPrefix	Any prefix string added to the tag. Use mostly for adding the "." to traced environment variables.
quoteTag	Indicates whether the tag should be quoted or not. Operator names are quoted.
tag	The tag name.
value	The associated trace value.

Definition at line 3589 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxString::getBLength(), INDENT_SPACING, RexxCode::isTraceable(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putCharB(), QUOTES_OVERHEAD, raw_string(), RexxString::set(), settings, RexxObject::stringValue(), TRACE_OVERHEAD, trace_prefix_table, trace_suppress, ActivationSettings::traceindent, RexxActivity::traceOutput(), and VALUE_MARKER.

Referenced by traceOperator(), and tracePrefix().

◆ tracePrefix()

void RexxActivation::tracePrefix	(	const char *	n,
		RexxObject *	v
	)

inline

Definition at line 424 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_PREFIX, and traceOperatorValue().

Referenced by RexxUnaryOperator::evaluate().

◆ traceResult()

void RexxActivation::traceResult ( RexxObject * v )

inline

Definition at line 432 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, TRACE_PREFIX_RESULT, trace_results, and traceValue().

◆ traceSetting()

RexxString * RexxActivation::traceSetting ( )

Definition at line 868 of file RexxActivation.cpp.

References RexxSource::formatTraceSetting(), settings, and ActivationSettings::traceOption.

Referenced by processTraceSetting().

◆ traceSourceString()

void RexxActivation::traceSourceString ( )

Definition at line 3757 of file RexxActivation.cpp.

References activity, ActivationSettings::flags, RexxString::getBLength(), RexxString::getStringData(), INSTRUCTION_OVERHEAD, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putCharB(), raw_string(), RexxString::set(), settings, source_traced, sourceString(), TRACE_PREFIX_ERROR, trace_prefix_table, and RexxActivity::traceOutput().

Referenced by traceClause().

◆ traceTaggedValue()

void RexxActivation::traceTaggedValue	(	int	prefix,
		const char *	tagPrefix,
		bool	quoteTag,
		RexxString *	tag,
		const char *	marker,
		RexxObject *	value,
		bool	quoteValue = `true`
	)

Trace an entry that's of the form 'tag => "value"'.

Parameters

prefix	The trace prefix tag to use.
tagPrefix	Any prefix string added to the tag. Use mostly for adding the "." to traced environment variables.
quoteTag	Indicates whether the tag should be quoted or not. Operator names are quoted.
tag	The tag name.
value	The associated trace value.
quoteValue	Indicates whether the value should be quoted or not.

Definition at line 3490 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxString::getBLength(), INDENT_SPACING, RexxCode::isTraceable(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putCharB(), QUOTES_OVERHEAD, raw_string(), RexxString::set(), settings, RexxObject::stringValue(), TRACE_OVERHEAD, trace_prefix_table, trace_suppress, ActivationSettings::traceindent, and RexxActivity::traceOutput().

Referenced by traceAssignment(), traceDotVariable(), traceFunction(), traceMessage(), and traceVariable().

◆ traceValue()

void RexxActivation::traceValue	(	RexxObject *	value,
		int	prefix
	)

◆ traceVariable()

void RexxActivation::traceVariable	(	RexxString *	n,
		RexxObject *	v
	)

inline

Definition at line 414 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, settings, TRACE_PREFIX_VARIABLE, traceTaggedValue(), and VALUE_MARKER.

Referenced by RexxStemVariable::evaluate(), and RexxParseVariable::evaluate().

◆ tracingAll()

bool RexxActivation::tracingAll ( void )

inline

Definition at line 441 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_all.

Referenced by command(), and run().

◆ tracingCommands()

bool RexxActivation::tracingCommands ( void )

inline

Definition at line 440 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_commands.

Referenced by command(), and RexxInstructionCommand::execute().

◆ tracingErrors()

bool RexxActivation::tracingErrors ( void )

inline

Definition at line 434 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_errors.

Referenced by command().

◆ tracingFailures()

bool RexxActivation::tracingFailures ( void )

inline

Definition at line 435 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_failures.

Referenced by command().

◆ tracingInstructions()

bool RexxActivation::tracingInstructions ( void )

inline

Definition at line 433 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_all.

Referenced by RexxInstructionAssignment::execute().

◆ tracingIntermediates()

bool RexxActivation::tracingIntermediates ( )

inline

Definition at line 388 of file RexxActivation.hpp.

References ActivationSettings::intermediate_trace, and settings.

Referenced by assignLocalCompoundVariable(), dropLocalCompoundVariable(), evaluateLocalCompoundVariable(), RexxCompoundVariable::expose(), and RexxTrigger::parse().

◆ tracingLabels()

bool RexxActivation::tracingLabels ( void )

inline

Definition at line 438 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_labels.

Referenced by run().

◆ tracingResults()

bool RexxActivation::tracingResults ( )

inline

Definition at line 390 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_results.

Referenced by RexxTrigger::parse().

◆ trap()

bool RexxActivation::trap	(	RexxString *	condition,
		RexxDirectory *	exception_object
	)

virtual

◆ trapDelay()

void RexxActivation::trapDelay ( RexxString * condition )

Definition at line 2288 of file RexxActivation.cpp.

References RexxDirectory::at(), checkTrapTable(), OREF_NULL, RexxArray::put(), settings, and ActivationSettings::traps.

Referenced by RexxInstructionCall::trap().

◆ trapOff()

void RexxActivation::trapOff ( RexxString * condition )

Definition at line 1629 of file RexxActivation.cpp.

References RexxDirectory::at(), checkTrapTable(), isInternalCall(), ActivationSettings::local_variables, OREF_NULL, RexxDirectory::remove(), RexxLocalVariables::setNovalueOff(), settings, RexxString::strCompare(), and ActivationSettings::traps.

Referenced by RexxInstructionCall::execute(), RexxInstructionSignal::execute(), and RexxInstructionSignal::trap().

◆ trapOn()

void RexxActivation::trapOn	(	RexxString *	condition,
		RexxInstructionCallBase *	handler
	)

Definition at line 1609 of file RexxActivation.cpp.

References checkTrapTable(), ActivationSettings::local_variables, new_array(), RexxDirectory::put(), RexxLocalVariables::setNovalueOn(), settings, RexxString::strCompare(), and ActivationSettings::traps.

Referenced by RexxInstructionCall::execute(), and RexxInstructionSignal::execute().

◆ trapState()

RexxString * RexxActivation::trapState ( RexxString * condition )

Definition at line 2266 of file RexxActivation.cpp.

References RexxDirectory::at(), RexxArray::get(), OREF_NULL, settings, and ActivationSettings::traps.

Referenced by processTraps().

◆ trapUndelay()

void RexxActivation::trapUndelay ( RexxString * condition )

Definition at line 2304 of file RexxActivation.cpp.

References RexxDirectory::at(), checkTrapTable(), OREF_NULL, RexxArray::put(), settings, and ActivationSettings::traps.

Referenced by RexxInstructionCall::trap().

◆ unindent()

void RexxActivation::unindent ( )

inline

Definition at line 385 of file RexxActivation.hpp.

References settings, and ActivationSettings::traceindent.

Referenced by RexxInstructionEndIf::execute(), RexxInstructionEnd::execute(), RexxInstructionDo::reExecute(), and removeBlock().

◆ unwindTrap()

void RexxActivation::unwindTrap ( RexxActivation * child )

Definition at line 2529 of file RexxActivation.cpp.

References condition_queue, handler_queue, isInterpret(), mergeTraps(), parent, putSettings(), settings, and unwindTrap().

Referenced by trap(), and unwindTrap().

◆ updateLocalVariable()

void RexxActivation::updateLocalVariable ( RexxVariable * variable )

inline

Definition at line 564 of file RexxActivation.hpp.

References ActivationSettings::local_variables, settings, and RexxLocalVariables::updateVariable().

Referenced by RexxStemVariable::procedureExpose().

◆ yield()

void RexxActivation::yield ( )

Definition at line 3943 of file RexxActivation.cpp.

References clause_boundary, external_yield, ActivationSettings::flags, and settings.

Referenced by RexxActivity::yield().

Friends And Related Function Documentation

◆ RexxSource

friend class RexxSource

friend

Definition at line 165 of file RexxActivation.hpp.

Member Data Documentation

◆ activation_context

int RexxActivation::activation_context

protected

Definition at line 676 of file RexxActivation.hpp.

Referenced by implicitExit(), inMethod(), isInternalCall(), isInternalLevelCall(), isInterpret(), isMethod(), isProgram(), isProgramLevelCall(), isProgramOrMethod(), isRoutine(), isTopLevel(), isTopLevelCall(), resolveDotVariable(), and RexxActivation().

◆ activity

RexxActivity* RexxActivation::activity

protected

◆ argcount

size_t RexxActivation::argcount

protected

Definition at line 663 of file RexxActivation.hpp.

Referenced by debugInterpret(), dispatch(), forward(), getArguments(), getMethodArgumentCount(), interpret(), live(), liveGeneral(), run(), and setArguments().

◆ arglist

RexxObject** RexxActivation::arglist

protected

Definition at line 661 of file RexxActivation.hpp.

Referenced by debugInterpret(), dispatch(), forward(), getArguments(), getMethodArgument(), getMethodArgumentList(), interpret(), live(), liveGeneral(), run(), and setArguments().

◆ arguments

RexxArray* RexxActivation::arguments

protected

Definition at line 656 of file RexxActivation.hpp.

Referenced by createStackFrame(), debugInterpret(), dispatch(), interpret(), live(), liveGeneral(), run(), and setArguments().

◆ blockNest

size_t RexxActivation::blockNest

protected

Definition at line 686 of file RexxActivation.hpp.

Referenced by addBlock(), hasActiveBlocks(), newDo(), removeBlock(), signalTo(), and terminateBlock().

◆ clause_boundary

const size_t RexxActivation::clause_boundary = 0x00010000

staticprotected

Definition at line 715 of file RexxActivation.hpp.

Referenced by externalTraceOff(), externalTraceOn(), halt(), processClauseBoundary(), run(), trap(), and yield().

◆ clause_exits

const size_t RexxActivation::clause_exits = 0x00100000

staticprotected

Definition at line 719 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and run().

◆ code

RexxCode* RexxActivation::code

protected

Definition at line 650 of file RexxActivation.hpp.

Referenced by debugInterpret(), debugPause(), getLabels(), getProgramName(), getPublicRoutines(), interpret(), live(), liveGeneral(), resolveProgramName(), RexxActivation(), run(), traceClause(), traceCompoundValue(), traceOperatorValue(), traceTaggedValue(), and traceValue().

◆ condition_queue

RexxQueue* RexxActivation::condition_queue

protected

Definition at line 683 of file RexxActivation.hpp.

Referenced by live(), liveGeneral(), mergeTraps(), processTraps(), run(), trap(), and unwindTrap().

◆ contextObject

RexxContext* RexxActivation::contextObject

protected

Definition at line 672 of file RexxActivation.hpp.

Referenced by getContextObject(), live(), liveGeneral(), and termination().

◆ current

RexxInstruction* RexxActivation::current

protected

Definition at line 666 of file RexxActivation.hpp.

Referenced by command(), currentLine(), debugInterpret(), debugPause(), getContextLine(), getContextLineNumber(), getCurrent(), getTraceBack(), internalCall(), internalCallTrap(), interpret(), live(), liveGeneral(), loadLibrary(), loadRequires(), rexxVariable(), run(), setCurrent(), and signalTo().

◆ debug_bypass

const size_t RexxActivation::debug_bypass = 0x00004000

staticprotected

Definition at line 713 of file RexxActivation.hpp.

Referenced by debugPause(), debugSkip(), exitFrom(), forward(), returnFrom(), and setTrace().

◆ debug_pause

bool RexxActivation::debug_pause

protected

Definition at line 668 of file RexxActivation.hpp.

Referenced by command(), debugInterpret(), debugPause(), debugSkip(), inDebug(), RexxActivation(), run(), setTrace(), and trap().

◆ debug_prompt_issued

const size_t RexxActivation::debug_prompt_issued = 0x00002000

staticprotected

Definition at line 712 of file RexxActivation.hpp.

Referenced by debugPause(), and setTrace().

◆ default_enable_commands

const bool RexxActivation::default_enable_commands = true

staticprotected

Definition at line 707 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ default_enable_macrospace

const bool RexxActivation::default_enable_macrospace = true

staticprotected

Definition at line 708 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ default_trace_flags

const size_t RexxActivation::default_trace_flags = trace_failures

staticprotected

Definition at line 702 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ dostack

RexxDoBlock* RexxActivation::dostack

protected

Definition at line 665 of file RexxActivation.hpp.

Referenced by live(), liveGeneral(), popBlock(), pushBlock(), signalTo(), terminateBlock(), and topBlock().

◆ elapsed_reset

const size_t RexxActivation::elapsed_reset = 0x20000000

staticprotected

Definition at line 729 of file RexxActivation.hpp.

Referenced by isElapsedTimerReset(), setElapsedTimerInvalid(), and setElapsedTimerValid().

◆ environmentList

RexxList* RexxActivation::environmentList

protected

Definition at line 679 of file RexxActivation.hpp.

Referenced by live(), liveGeneral(), popEnvironment(), pushEnvironment(), and termination().

◆ execution_state

int RexxActivation::execution_state

protected

Definition at line 674 of file RexxActivation.hpp.

Referenced by exitFrom(), forward(), implicitExit(), reply(), returnFrom(), RexxActivation(), run(), and signalTo().

◆ external_yield

const size_t RexxActivation::external_yield = 0x00200000

staticprotected

Definition at line 720 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and yield().

◆ forwarded

const size_t RexxActivation::forwarded = 0x00400000

staticprotected

Definition at line 721 of file RexxActivation.hpp.

Referenced by forward(), isForwarded(), and trap().

◆ guarded_method

const size_t RexxActivation::guarded_method = 0x40000000

staticprotected

Definition at line 730 of file RexxActivation.hpp.

Referenced by isGuarded(), and setGuarded().

◆ halt_condition

const size_t RexxActivation::halt_condition = 0x00020000

staticprotected

Definition at line 716 of file RexxActivation.hpp.

Referenced by halt(), and processClauseBoundary().

◆ handler_queue

RexxQueue* RexxActivation::handler_queue

protected

Definition at line 681 of file RexxActivation.hpp.

Referenced by live(), liveGeneral(), mergeTraps(), processTraps(), run(), trap(), and unwindTrap().

◆ lookaside_size

size_t RexxActivation::lookaside_size

protected

Definition at line 687 of file RexxActivation.hpp.

◆ named_argcount

size_t RexxActivation::named_argcount

protected

Definition at line 664 of file RexxActivation.hpp.

Referenced by debugInterpret(), dispatch(), forward(), getMethodNamedArgumentCount(), interpret(), live(), liveGeneral(), run(), and setArguments().

◆ next

RexxInstruction* RexxActivation::next

protected

Definition at line 667 of file RexxActivation.hpp.

Referenced by debugPause(), exitFrom(), forward(), getNext(), live(), liveGeneral(), reply(), returnFrom(), run(), setNext(), and signalTo().

◆ object_scope

int RexxActivation::object_scope

protected

Definition at line 669 of file RexxActivation.hpp.

Referenced by getObjectVariables(), guardOff(), guardOn(), guardWait(), isObjectScopeLocked(), RexxActivation(), and run().

◆ objnotify

RexxMessage* RexxActivation::objnotify

protected

Definition at line 677 of file RexxActivation.hpp.

Referenced by live(), liveGeneral(), setObjNotify(), and trap().

◆ parent

RexxActivation* RexxActivation::parent

protected

Definition at line 655 of file RexxActivation.hpp.

Referenced by cleanupLocalVariables(), external(), getContextLine(), getContextLineNumber(), getRandomSeed(), getReceiver(), live(), liveGeneral(), popEnvironment(), procedureExpose(), propagateNumericSettings(), pushEnvironment(), raiseExit(), resolveDotVariable(), returnFrom(), RexxActivation(), rexxVariable(), run(), setDigits(), setForm(), setFuzz(), signalTo(), trap(), and unwindTrap().

◆ pending_count

size_t RexxActivation::pending_count

protected

Definition at line 680 of file RexxActivation.hpp.

Referenced by mergeTraps(), processClauseBoundary(), processTraps(), run(), and trap().

◆ procedure_valid

const size_t RexxActivation::procedure_valid = 0x00008000

staticprotected

Definition at line 714 of file RexxActivation.hpp.

Referenced by procedureExpose(), and run().

◆ random_seed

uint64_t RexxActivation::random_seed

protected

Definition at line 684 of file RexxActivation.hpp.

Referenced by adjustRandomSeed(), getRandomSeed(), and RexxActivation().

◆ random_set

bool RexxActivation::random_set

protected

Definition at line 685 of file RexxActivation.hpp.

◆ receiver

RexxObject* RexxActivation::receiver

protected

Definition at line 653 of file RexxActivation.hpp.

Referenced by createStackFrame(), debugInterpret(), dispatch(), forward(), getObjectVariables(), getReceiver(), getVariableDictionary(), guardOn(), internalCall(), live(), liveGeneral(), and run().

◆ reply_issued

const size_t RexxActivation::reply_issued = 0x00800000

staticprotected

Definition at line 722 of file RexxActivation.hpp.

Referenced by exitFrom(), forward(), reply(), returnFrom(), and RexxActivation().

◆ result

RexxObject* RexxActivation::result

protected

Definition at line 670 of file RexxActivation.hpp.

Referenced by exitFrom(), forward(), live(), liveGeneral(), reply(), returnFrom(), and run().

◆ return_status_set

const size_t RexxActivation::return_status_set = 0x08000000

staticprotected

Definition at line 726 of file RexxActivation.hpp.

Referenced by getContextReturnStatus(), rexxVariable(), and setReturnStatus().

◆ scope

RexxClass* RexxActivation::scope

protected

Definition at line 652 of file RexxActivation.hpp.

Referenced by formatSourcelessTraceLine(), getObjectVariables(), getVariableDictionary(), guardOn(), live(), RexxActivation(), run(), and traceEntry().

◆ set_trace_off

const size_t RexxActivation::set_trace_off = 0x02000000

staticprotected

Definition at line 724 of file RexxActivation.hpp.

Referenced by externalTraceOff(), and processClauseBoundary().

◆ set_trace_on

const size_t RexxActivation::set_trace_on = 0x01000000

staticprotected

Definition at line 723 of file RexxActivation.hpp.

Referenced by externalTraceOn(), and processClauseBoundary().

◆ settings

ActivationSettings RexxActivation::settings

protected

Definition at line 648 of file RexxActivation.hpp.

Referenced by addLocalRoutine(), callExternalRexx(), checkTrapTable(), cleanupLocalVariables(), clearTraceSettings(), closeStreams(), conditionalPauseInstruction(), debugInterpret(), debugPause(), debugSkip(), digits(), dispatch(), enableCommands(), enableMacrospace(), exitFrom(), externalCall(), externalTraceOff(), externalTraceOn(), form(), formatTrace(), forward(), fuzz(), getAddress(), getCallname(), getConditionObj(), getContextReturnStatus(), getEffectiveSecurityManager(), getElapsed(), getIndent(), getLocalStemVariable(), getLocalVariable(), getLocalVariables(), getMessageName(), getNumericSettings(), getObjectVariables(), getProgramArgument(), getProgramArgumentCount(), getProgramArgumentlist(), getProgramNamedArgumentCount(), getSecurityManager(), getSettings(), getStreams(), getTime(), guardOff(), guardOn(), guardWait(), halt(), inDebug(), indent(), internalCall(), internalCallTrap(), isElapsedTimerReset(), isExternalTraceOn(), isForwarded(), isGuarded(), live(), liveGeneral(), localStemVariableExists(), localVariableExists(), newDo(), novalueEnabled(), pauseCommand(), pauseInstruction(), pauseLabel(), procedureExpose(), processClauseBoundary(), propagateNumericSettings(), putLocalVariable(), putSettings(), reply(), returnFrom(), RexxActivation(), rexxVariable(), run(), setAddress(), setCallType(), setConditionObj(), setDefaultAddress(), setDigits(), setElapsedTimerInvalid(), setElapsedTimerValid(), setExternalTraceOff(), setExternalTraceOn(), setForm(), setFuzz(), setGuarded(), setIndent(), setLocalVariableDictionary(), setReturnStatus(), setTrace(), signalTo(), sourceString(), terminateBlock(), toggleAddress(), traceAssignment(), traceClause(), traceCommand(), traceCompound(), traceCompoundAssignment(), traceCompoundName(), traceCompoundValue(), traceDotVariable(), traceEntry(), traceFunction(), traceInstruction(), traceIntermediate(), traceLabel(), traceMessage(), traceOperator(), traceOperatorValue(), tracePrefix(), traceResult(), traceSetting(), traceSourceString(), traceTaggedValue(), traceValue(), traceVariable(), tracingAll(), tracingCommands(), tracingErrors(), tracingFailures(), tracingInstructions(), tracingIntermediates(), tracingLabels(), tracingResults(), trap(), trapDelay(), trapOff(), trapOn(), trapState(), trapUndelay(), unindent(), unwindTrap(), updateLocalVariable(), and yield().

◆ single_step

const size_t RexxActivation::single_step = 0x00000800

staticprotected

Definition at line 710 of file RexxActivation.hpp.

◆ single_step_nested

const size_t RexxActivation::single_step_nested = 0x00001000

staticprotected

Definition at line 711 of file RexxActivation.hpp.

◆ source_traced

const size_t RexxActivation::source_traced = 0x00080000

staticprotected

Definition at line 718 of file RexxActivation.hpp.

Referenced by traceClause(), traceEntry(), and traceSourceString().

◆ sourceObject

RexxSource* RexxActivation::sourceObject

protected

Definition at line 651 of file RexxActivation.hpp.

Referenced by getEffectiveSourceObject(), getSourceObject(), RexxActivation(), setDigits(), setForm(), and setFuzz().

◆ stack

RexxExpressionStack RexxActivation::stack

protected

Definition at line 649 of file RexxActivation.hpp.

Referenced by callExternalRexx(), expose(), getStack(), internalCallTrap(), iterate(), live(), liveGeneral(), procedureExpose(), RexxActivation(), run(), and termination().

◆ trace_all

const size_t RexxActivation::trace_all = 0x00000002

staticprotected

Definition at line 693 of file RexxActivation.hpp.

Referenced by conditionalPauseInstruction(), pauseInstruction(), processTraceSetting(), traceInstruction(), tracingAll(), and tracingInstructions().

◆ trace_all_flags

const size_t RexxActivation::trace_all_flags = (trace_all | trace_labels | trace_commands)

staticprotected

Definition at line 703 of file RexxActivation.hpp.

◆ trace_commands

const size_t RexxActivation::trace_commands = 0x00000010

staticprotected

Definition at line 696 of file RexxActivation.hpp.

Referenced by pauseCommand(), processTraceSetting(), traceCommand(), and tracingCommands().

◆ trace_debug

const size_t RexxActivation::trace_debug = 0x00000001

staticprotected

Definition at line 692 of file RexxActivation.hpp.

Referenced by conditionalPauseInstruction(), enableExternalTrace(), exitFrom(), externalTraceOn(), forward(), inDebug(), pauseCommand(), pauseInstruction(), pauseLabel(), processClauseBoundary(), processTraceSetting(), returnFrom(), setTrace(), and traceClause().

◆ trace_errors

const size_t RexxActivation::trace_errors = 0x00000040

staticprotected

Definition at line 698 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and tracingErrors().

◆ trace_failures

const size_t RexxActivation::trace_failures = 0x00000080

staticprotected

Definition at line 699 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and tracingFailures().

◆ trace_flags

const size_t RexxActivation::trace_flags = 0x000001ff

staticprotected

Definition at line 701 of file RexxActivation.hpp.

Referenced by clearTraceSettings(), and setTrace().

◆ trace_intermediates

const size_t RexxActivation::trace_intermediates = 0x00000008

staticprotected

Definition at line 695 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and setTrace().

◆ trace_intermediates_flags

const size_t RexxActivation::trace_intermediates_flags = (trace_all | trace_labels | trace_results | trace_commands | trace_intermediates)

staticprotected

Definition at line 705 of file RexxActivation.hpp.

◆ trace_labels

const size_t RexxActivation::trace_labels = 0x00000020

staticprotected

Definition at line 697 of file RexxActivation.hpp.

Referenced by pauseLabel(), processTraceSetting(), traceLabel(), and tracingLabels().

◆ trace_off

const size_t RexxActivation::trace_off = 0x00000000

staticprotected

Definition at line 691 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and processTraceSetting().

◆ trace_on

const size_t RexxActivation::trace_on = 0x00040000

staticprotected

Definition at line 717 of file RexxActivation.hpp.

Referenced by isExternalTraceOn(), setExternalTraceOff(), and setExternalTraceOn().

◆ trace_results

const size_t RexxActivation::trace_results = 0x00000004

staticprotected

Definition at line 694 of file RexxActivation.hpp.

Referenced by processTraceSetting(), traceResult(), and tracingResults().

◆ trace_results_flags

const size_t RexxActivation::trace_results_flags = (trace_all | trace_labels | trace_results | trace_commands)

staticprotected

Definition at line 704 of file RexxActivation.hpp.

Referenced by enableExternalTrace(), externalTraceOn(), and processClauseBoundary().

◆ trace_suppress

const size_t RexxActivation::trace_suppress = 0x00000100

staticprotected

Definition at line 700 of file RexxActivation.hpp.

Referenced by debugPause(), debugSkip(), setTrace(), traceClause(), traceCompoundValue(), traceOperatorValue(), traceTaggedValue(), and traceValue().

◆ transfer_failed

const size_t RexxActivation::transfer_failed = 0x10000000

staticprotected

Definition at line 727 of file RexxActivation.hpp.

Referenced by run().

◆ trapinfo

RexxArray* RexxActivation::trapinfo

protected

Definition at line 671 of file RexxActivation.hpp.

Referenced by live(), and liveGeneral().

◆ traps_copied

const size_t RexxActivation::traps_copied = 0x04000000

staticprotected

Definition at line 725 of file RexxActivation.hpp.

Referenced by checkTrapTable(), and RexxActivation().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RexxActivation() [1/5]

◆ RexxActivation() [2/5]

◆ RexxActivation() [3/5]

◆ RexxActivation() [4/5]

◆ RexxActivation() [5/5]

Member Function Documentation

◆ addBlock()

◆ addLocalRoutine()

◆ adjustRandomSeed()

◆ assignLocalCompoundVariable()

◆ cacheLocalVariable()

◆ callExternalRexx()

◆ callMacroSpaceFunction()

◆ checkTrapTable()

◆ cleanupLocalVariables()

◆ clearTraceSettings()

◆ closeStreams()

◆ command()

◆ conditionalPauseInstruction()

◆ createStackFrame()

◆ currentLine()

◆ debugInterpret()

◆ debugPause()

◆ debugSkip()

◆ digits()

◆ directRetriever()

◆ dispatch()

◆ dropLocalCompoundVariable()

◆ dropLocalStem()

◆ dropLocalVariable()

◆ enableCommands() [1/2]

◆ enableCommands() [2/2]

◆ enableExternalTrace()

◆ enableMacrospace() [1/2]

◆ enableMacrospace() [2/2]

◆ evaluateLocalCompoundVariable()

◆ exitFrom()

◆ expose()

◆ exposeLocalCompoundVariable()

◆ external()

◆ externalCall()

◆ externalTraceOff()

◆ externalTraceOn()

◆ findClass()

◆ findRexxContext()

◆ form()

◆ formatSourcelessTraceLine()

◆ formatTrace()

◆ forward()

◆ fuzz()

◆ getActivity()

◆ getAddress()

◆ getAllLocalVariables()

◆ getArguments()

◆ getCallname()

◆ getConditionObj()

◆ getContextLine()

◆ getContextLineNumber()

◆ getContextObject()

◆ getContextReturnStatus()

◆ getCurrent()

◆ getEffectiveSecurityManager()

◆ getEffectiveSourceObject()

◆ getElapsed()

◆ getIndent()

◆ getLabels()

◆ getLocalCompoundVariable()

◆ getLocalCompoundVariableRealValue()

◆ getLocalCompoundVariableValue()

◆ getLocalEnvironment()

◆ getLocalStem()

◆ getLocalStemVariable()