#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 *	getPackageObject ()

PackageClass *	getEffectivePackageObject ()

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 ()

void	setInRexxPackage ()

bool	isInRexxPackage ()

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 RexxText *	makeText ()

virtual void	copyIntoTail (RexxCompoundTail *buffer)

virtual RexxString *	primitiveMakeString ()

virtual RexxText *	primitiveMakeText ()

virtual RexxArray *	makeArray ()

virtual RexxString *	stringValue ()

virtual RexxText *	textValue ()

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 *)

virtual RexxObject *	dynamicTarget (RexxObject **arguments, size_t count, size_t named_count)

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 175 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 188 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 390 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 313 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 397 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 4324 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 4538 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 629 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 2955 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 2841 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 1620 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 635 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 405 of file RexxActivation.hpp.

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

Referenced by setTrace().

◆ closeStreams()

void RexxActivation::closeStreams ( )

Definition at line 4417 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 4130 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 459 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 4641 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 1373 of file RexxActivation.cpp.

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

Referenced by RexxString::checkTE(), and RexxActivity::reraiseException().

◆ debugInterpret()

void RexxActivation::debugInterpret ( RexxString * codestring )

Definition at line 2619 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 4012 of file RexxActivation.cpp.

References activity, code, current, debug_bypass, debug_pause, debug_prompt_issued, debugInterpret(), ActivationSettings::flags, RexxString::getChar(), RexxString::getLength(), 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 873 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 2106 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 506 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 4567 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 552 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 591 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 2138 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 2220 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 3926 of file RexxActivation.cpp.

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

Referenced by SysInterpreterInstance::setupProgram().

◆ enableMacrospace() [1/2]

bool RexxActivation::enableMacrospace ( )

Definition at line 2146 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 2228 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 4470 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 1517 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 1418 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 4518 of file RexxActivation.cpp.

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

Referenced by RexxCompoundVariable::procedureExpose().

◆ external()

RexxActivation * RexxActivation::external ( )

Definition at line 1683 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 2887 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 4000 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 3987 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 3050 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 2255 of file RexxActivation.cpp.

◆ form()

bool RexxActivation::form ( )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2122 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 4693 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 3821 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 1435 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 2114 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 407 of file RexxActivation.hpp.

References activity.

Referenced by RexxInstructionSay::execute().

◆ getAddress()

RexxString* RexxActivation::getAddress ( )

inline

Definition at line 413 of file RexxActivation.hpp.

References ActivationSettings::current_env, and settings.

Referenced by RexxInstructionCommand::execute().

◆ getAllLocalVariables()

RexxDirectory* RexxActivation::getAllLocalVariables ( )

inline

Definition at line 524 of file RexxActivation.hpp.

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

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

◆ getArguments()

RexxArray* RexxActivation::getArguments ( )

inline

Definition at line 497 of file RexxActivation.hpp.

References argcount, arglist, and new_array().

Referenced by createStackFrame().

◆ getCallname()

RexxString* RexxActivation::getCallname ( )

inline

Definition at line 409 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 414 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 2760 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 2781 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 2743 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 2802 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 410 of file RexxActivation.hpp.

References current.

◆ getEffectivePackageObject()

PackageClass* RexxActivation::getEffectivePackageObject ( )

inline

Definition at line 379 of file RexxActivation.hpp.

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

◆ 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 4603 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 3249 of file RexxActivation.cpp.

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

◆ getIndent()

size_t RexxActivation::getIndent ( )

inline

Definition at line 403 of file RexxActivation.hpp.

References settings, and ActivationSettings::traceindent.

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

◆ getLabels()

RexxDirectory * RexxActivation::getLabels ( )

Definition at line 4300 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 4508 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 4498 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 4488 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 4621 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 547 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 538 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 529 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 519 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 3002 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 408 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 487 of file RexxActivation.hpp.

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

◆ getMethodArgumentCount()

size_t RexxActivation::getMethodArgumentCount ( )

inline

Definition at line 485 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 484 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 486 of file RexxActivation.hpp.

References named_argcount.

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

◆ getNext()

RexxInstruction* RexxActivation::getNext ( )

inline

Definition at line 416 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 2277 of file RexxActivation.cpp.

References ActivationSettings::numericSettings, and settings.

Referenced by RexxNativeActivation::getNumericSettings().

◆ getObjectVariables()

RexxVariableDictionary * RexxActivation::getObjectVariables ( )

Definition at line 1845 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 ( )

virtual

Retrieve the package for the current execution context.

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

Reimplemented from RexxActivationBase.

Definition at line 4464 of file RexxActivation.cpp.

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

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

◆ getPackageObject()

PackageClass* RexxActivation::getPackageObject ( )

inline

Definition at line 371 of file RexxActivation.hpp.

References RexxSource::getPackage(), and sourceObject.

◆ getParentContextObject()

RexxObject * RexxActivation::getParentContextObject ( )

Get the context object for the parent of this activation.

Returns: The created context object.

Definition at line 2821 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 503 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 500 of file RexxActivation.hpp.

References ActivationSettings::parent_argcount, and settings.

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

◆ getProgramArgumentlist()

RexxObject** RexxActivation::getProgramArgumentlist ( )

inline

Definition at line 499 of file RexxActivation.hpp.

References ActivationSettings::parent_arglist, and settings.

◆ getProgramName()

RexxString * RexxActivation::getProgramName ( )

Definition at line 4292 of file RexxActivation.cpp.

References code, and RexxCode::getProgramName().

◆ getProgramNamedArgumentCount()

size_t RexxActivation::getProgramNamedArgumentCount ( )

inline

Definition at line 501 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 4347 of file RexxActivation.cpp.

References code, and RexxCode::getPublicRoutines().

◆ getRandomSeed()

uint64_t RexxActivation::getRandomSeed ( RexxInteger * seed )

Definition at line 3284 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 2289 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 471 of file RexxActivation.hpp.

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

◆ 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 2243 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 4591 of file RexxActivation.cpp.

References ActivationSettings::securityManager, and settings.

◆ getSettings()

void RexxActivation::getSettings ( ActivationSettings & s )

inline

Definition at line 411 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 421 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 4727 of file RexxActivation.cpp.

References activity, and RexxActivity::generateStackFrames().

Referenced by RexxContext::getStackFrames().

◆ getStreams()

RexxDirectory * RexxActivation::getStreams ( )

Definition at line 1963 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 4630 of file RexxActivation.cpp.

References activity, and RexxActivity::getThreadLocal().

Referenced by rexxVariable().

◆ getTime()

RexxDateTime RexxActivation::getTime ( )

Definition at line 3218 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 3212 of file RexxActivation.cpp.

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

Referenced by createStackFrame().

◆ getVariableDictionary()

RexxVariableDictionary* RexxActivation::getVariableDictionary ( )

inline

Definition at line 473 of file RexxActivation.hpp.

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

Referenced by GetConcurrencyInfos(), and getReserveCount().

◆ 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 2085 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 3181 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 3956 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 2497 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 398 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 419 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 400 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 399 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 3132 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 3161 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 2600 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 480 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by getTime().

◆ isExternalTraceOn()

bool RexxActivation::isExternalTraceOn ( )

inline

Definition at line 475 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 466 of file RexxActivation.hpp.

References ActivationSettings::flags, forwarded, and settings.

Referenced by RexxActivity::raiseException().

◆ isGuarded()

bool RexxActivation::isGuarded ( )

inline

Definition at line 467 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(), getEffectivePackageObject(), 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 469 of file RexxActivation.hpp.

References object_scope, and SCOPE_RESERVED.

Referenced by GetConcurrencyInfos().

◆ 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 2266 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 465 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 1277 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 1329 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 1098 of file RexxActivation.cpp.

◆ liveGeneral()

void RexxActivation::liveGeneral ( int reason )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 1158 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 3111 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 3093 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 4528 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 559 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 567 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 2526 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 395 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 615 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 607 of file RexxActivation.hpp.

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

Referenced by handleNovalueEvent().

◆ novalueHandler()

RexxObject * RexxActivation::novalueHandler ( RexxString * name )

Definition at line 4442 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 161 of file RexxActivation.cpp.

References new_object(), and T_Activation.

◆ pauseCommand()

void RexxActivation::pauseCommand ( )

inline

Definition at line 461 of file RexxActivation.hpp.

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

◆ pauseInstruction()

void RexxActivation::pauseInstruction ( )

inline

Definition at line 458 of file RexxActivation.hpp.

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

◆ pauseLabel()

void RexxActivation::pauseLabel ( )

inline

Definition at line 460 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 391 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 4389 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 1389 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 1031 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 821 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 2130 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 2210 of file RexxActivation.cpp.

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

◆ pushBlock()

void RexxActivation::pushBlock ( RexxDoBlock * block )

inline

Definition at line 390 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 4364 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 575 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 412 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 1702 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 3321 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 396 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 1218 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 3266 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 3069 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 3037 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 1879 of file RexxActivation.cpp.

References RexxDirectory::at(), SecurityManager::checkStreamAccess(), getEffectiveSecurityManager(), RexxString::getLength(), 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 1238 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 517 of file RexxActivation.cpp.

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

◆ senderActivation()

RexxActivation * RexxActivation::senderActivation ( )

Definition at line 2585 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 2036 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 4736 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 389 of file RexxActivation.hpp.

References ActivationSettings::calltype, settings, and type.

◆ setConditionObj()

void RexxActivation::setConditionObj ( RexxDirectory * condition )

inline

Definition at line 415 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 418 of file RexxActivation.hpp.

References current.

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

◆ setDefaultAddress()

void RexxActivation::setDefaultAddress ( RexxString * address )

Definition at line 2049 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 2157 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 2162 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 481 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by resetElapsed().

◆ setElapsedTimerValid()

void RexxActivation::setElapsedTimerValid ( )

inline

Definition at line 482 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by getTime().

◆ setExternalTraceOff()

void RexxActivation::setExternalTraceOff ( )

inline

Definition at line 477 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_on.

Referenced by processClauseBoundary().

◆ setExternalTraceOn()

void RexxActivation::setExternalTraceOn ( )

inline

Definition at line 476 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 2193 of file RexxActivation.cpp.

References RexxSource::getForm(), and sourceObject.

◆ setForm() [2/2]

void RexxActivation::setForm ( bool formVal )

virtual

Reimplemented from RexxActivationBase.

Definition at line 2200 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 2174 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 2181 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 468 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 402 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 4556 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 585 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 659 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 417 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 4354 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 4285 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 916 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 945 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 1998 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 2062 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 4308 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 394 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 393 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 1589 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 2024 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 392 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 442 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 4091 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 455 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 446 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 447 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 444 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 445 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 3714 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxString::getLength(), RexxCompoundTail::getLength(), RexxCompoundTail::getTail(), INDENT_SPACING, RexxCode::isTraceable(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putChar(), 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 3696 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 432 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 3435 of file RexxActivation.cpp.

References activity, RexxActivity::buildMessage(), ActivationSettings::flags, RexxActivationBase::getExecutable(), RexxClass::getId(), RexxString::getLength(), 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 434 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 452 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 429 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 453 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 436 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 438 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 3622 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxString::getLength(), INDENT_SPACING, RexxCode::isTraceable(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putChar(), 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 440 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 448 of file RexxActivation.hpp.

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

◆ traceSetting()

RexxString * RexxActivation::traceSetting ( )

Definition at line 901 of file RexxActivation.cpp.

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

Referenced by processTraceSetting().

◆ traceSourceString()

void RexxActivation::traceSourceString ( )

Definition at line 3790 of file RexxActivation.cpp.

References activity, ActivationSettings::flags, RexxString::getLength(), RexxString::getStringData(), INSTRUCTION_OVERHEAD, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putChar(), 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 3523 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxString::getLength(), INDENT_SPACING, RexxCode::isTraceable(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, RexxString::put(), RexxString::putChar(), 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 430 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 457 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 456 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 450 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_errors.

Referenced by command().

◆ tracingFailures()

bool RexxActivation::tracingFailures ( void )

inline

Definition at line 451 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_failures.

Referenced by command().

◆ tracingInstructions()

bool RexxActivation::tracingInstructions ( void )

inline

Definition at line 449 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_all.

Referenced by RexxInstructionAssignment::execute().

◆ tracingIntermediates()

bool RexxActivation::tracingIntermediates ( )

inline

Definition at line 404 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 454 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_labels.

Referenced by run().

◆ tracingResults()

bool RexxActivation::tracingResults ( )

inline

Definition at line 406 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 2321 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 1662 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 1642 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 2299 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 2337 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 401 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 2562 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 580 of file RexxActivation.hpp.

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

Referenced by RexxStemVariable::procedureExpose().

◆ yield()

void RexxActivation::yield ( )

Definition at line 3976 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 692 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 679 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 677 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 672 of file RexxActivation.hpp.

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

◆ blockNest

size_t RexxActivation::blockNest

protected

Definition at line 702 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 731 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 735 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and run().

◆ code

RexxCode* RexxActivation::code

protected

Definition at line 666 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 699 of file RexxActivation.hpp.

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

◆ contextObject

RexxContext* RexxActivation::contextObject

protected

Definition at line 688 of file RexxActivation.hpp.

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

◆ current

RexxInstruction* RexxActivation::current

protected

Definition at line 682 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 729 of file RexxActivation.hpp.

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

◆ debug_pause

bool RexxActivation::debug_pause

protected

Definition at line 684 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 728 of file RexxActivation.hpp.

Referenced by debugPause(), and setTrace().

◆ default_enable_commands

const bool RexxActivation::default_enable_commands = true

staticprotected

Definition at line 723 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ default_enable_macrospace

const bool RexxActivation::default_enable_macrospace = true

staticprotected

Definition at line 724 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ default_trace_flags

const size_t RexxActivation::default_trace_flags = trace_failures

staticprotected

Definition at line 718 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ dostack

RexxDoBlock* RexxActivation::dostack

protected

Definition at line 681 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 745 of file RexxActivation.hpp.

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

◆ environmentList

RexxList* RexxActivation::environmentList

protected

Definition at line 695 of file RexxActivation.hpp.

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

◆ execution_state

int RexxActivation::execution_state

protected

Definition at line 690 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 736 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and yield().

◆ forwarded

const size_t RexxActivation::forwarded = 0x00400000

staticprotected

Definition at line 737 of file RexxActivation.hpp.

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

◆ guarded_method

const size_t RexxActivation::guarded_method = 0x40000000

staticprotected

Definition at line 746 of file RexxActivation.hpp.

Referenced by isGuarded(), and setGuarded().

◆ halt_condition

const size_t RexxActivation::halt_condition = 0x00020000

staticprotected

Definition at line 732 of file RexxActivation.hpp.

Referenced by halt(), and processClauseBoundary().

◆ handler_queue

RexxQueue* RexxActivation::handler_queue

protected

Definition at line 697 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 703 of file RexxActivation.hpp.

◆ named_argcount

size_t RexxActivation::named_argcount

protected

Definition at line 680 of file RexxActivation.hpp.

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

◆ next

RexxInstruction* RexxActivation::next

protected

Definition at line 683 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 685 of file RexxActivation.hpp.

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

◆ objnotify

RexxMessage* RexxActivation::objnotify

protected

Definition at line 693 of file RexxActivation.hpp.

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

◆ parent

RexxActivation* RexxActivation::parent

protected

Definition at line 671 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 696 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 730 of file RexxActivation.hpp.

Referenced by procedureExpose(), and run().

◆ random_seed

uint64_t RexxActivation::random_seed

protected

Definition at line 700 of file RexxActivation.hpp.

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

◆ random_set

bool RexxActivation::random_set

protected

Definition at line 701 of file RexxActivation.hpp.

◆ receiver

RexxObject* RexxActivation::receiver

protected

Definition at line 669 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 738 of file RexxActivation.hpp.

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

◆ result

RexxObject* RexxActivation::result

protected

Definition at line 686 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 742 of file RexxActivation.hpp.

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

◆ scope

RexxClass* RexxActivation::scope

protected

Definition at line 668 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 740 of file RexxActivation.hpp.

Referenced by externalTraceOff(), and processClauseBoundary().

◆ set_trace_on

const size_t RexxActivation::set_trace_on = 0x01000000

staticprotected

Definition at line 739 of file RexxActivation.hpp.

Referenced by externalTraceOn(), and processClauseBoundary().

◆ settings

ActivationSettings RexxActivation::settings

protected

Definition at line 664 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 726 of file RexxActivation.hpp.

◆ single_step_nested

const size_t RexxActivation::single_step_nested = 0x00001000

staticprotected

Definition at line 727 of file RexxActivation.hpp.

◆ source_traced

const size_t RexxActivation::source_traced = 0x00080000

staticprotected

Definition at line 734 of file RexxActivation.hpp.

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

◆ sourceObject

RexxSource* RexxActivation::sourceObject

protected

Definition at line 667 of file RexxActivation.hpp.

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

◆ stack

RexxExpressionStack RexxActivation::stack

protected

Definition at line 665 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 709 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 719 of file RexxActivation.hpp.

◆ trace_commands

const size_t RexxActivation::trace_commands = 0x00000010

staticprotected

Definition at line 712 of file RexxActivation.hpp.

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

◆ trace_debug

const size_t RexxActivation::trace_debug = 0x00000001

staticprotected

Definition at line 708 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 714 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and tracingErrors().

◆ trace_failures

const size_t RexxActivation::trace_failures = 0x00000080

staticprotected

Definition at line 715 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and tracingFailures().

◆ trace_flags

const size_t RexxActivation::trace_flags = 0x000001ff

staticprotected

Definition at line 717 of file RexxActivation.hpp.

Referenced by clearTraceSettings(), and setTrace().

◆ trace_intermediates

const size_t RexxActivation::trace_intermediates = 0x00000008

staticprotected

Definition at line 711 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 721 of file RexxActivation.hpp.

◆ trace_labels

const size_t RexxActivation::trace_labels = 0x00000020

staticprotected

Definition at line 713 of file RexxActivation.hpp.

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

◆ trace_off

const size_t RexxActivation::trace_off = 0x00000000

staticprotected

Definition at line 707 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and processTraceSetting().

◆ trace_on

const size_t RexxActivation::trace_on = 0x00040000

staticprotected

Definition at line 733 of file RexxActivation.hpp.

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

◆ trace_results

const size_t RexxActivation::trace_results = 0x00000004

staticprotected

Definition at line 710 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 720 of file RexxActivation.hpp.

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

◆ trace_suppress

const size_t RexxActivation::trace_suppress = 0x00000100

staticprotected

Definition at line 716 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 743 of file RexxActivation.hpp.

Referenced by run().

◆ trapinfo

RexxArray* RexxActivation::trapinfo

protected

Definition at line 687 of file RexxActivation.hpp.

Referenced by live(), and liveGeneral().

◆ traps_copied

const size_t RexxActivation::traps_copied = 0x04000000

staticprotected

Definition at line 741 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()

◆ getEffectivePackageObject()

◆ getEffectiveSecurityManager()

◆ getEffectiveSourceObject()

◆ getElapsed()

◆ getIndent()

◆ getLabels()

◆ getLocalCompoundVariable()

◆ getLocalCompoundVariableRealValue()

◆ getLocalCompoundVariableValue()

◆ getLocalEnvironment()

◆ getLocalStem()