ooRexx  4.2.0-source
About: ooRexx (Open Object Rexx) is a free implementation of Object Rexx. Object Rexx is an enhancement of the classic Rexx interpreter; a full-featured programming language with a human-oriented syntax.
  Fossies Dox: ooRexx-4.2.0-source.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)  

RexxActivation Class Reference

#include <RexxActivation.hpp>

Inheritance diagram for RexxActivation:
[legend]
Collaboration diagram for RexxActivation:
[legend]

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, RexxMethod *_method, RexxCode *_code)
 
 RexxActivation (RexxActivity *_activity, 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)
 
RexxObjectdispatch ()
 
size_t digits ()
 
size_t fuzz ()
 
bool form ()
 
void setDigits (size_t)
 
void setFuzz (size_t)
 
void setForm (bool)
 
void setDigits ()
 
void setFuzz ()
 
void setForm ()
 
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 ()
 
RexxObjectrun (RexxObject *_receiver, RexxString *msgname, RexxObject **_arglist, size_t _argcount, RexxInstruction *start, ProtectedObject &resultObj)
 
RexxObjectrun (RexxObject **_arglist, size_t _argcount, ProtectedObject &_result)
 
void reply (RexxObject *)
 
RexxObjectforward (RexxObject *, RexxString *, RexxObject *, RexxObject **, 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 *)
 
void raise (RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *, RexxDirectory *)
 
void toggleAddress ()
 
void guardOn ()
 
void raiseExit (RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *, RexxDirectory *)
 
RexxActivationsenderActivation ()
 
RexxActivationexternal ()
 
void interpret (RexxString *)
 
void signalTo (RexxInstruction *)
 
void guardWait ()
 
void debugSkip (wholenumber_t, bool)
 
RexxStringtraceSetting ()
 
void iterate (RexxString *)
 
void leaveLoop (RexxString *)
 
void trapOn (RexxString *, RexxInstructionCallBase *)
 
void trapOff (RexxString *)
 
void setAddress (RexxString *)
 
void signalValue (RexxString *)
 
RexxStringtrapState (RexxString *)
 
void trapDelay (RexxString *)
 
void trapUndelay (RexxString *)
 
bool callExternalRexx (RexxString *, RexxObject **, size_t, RexxString *, ProtectedObject &)
 
RexxObjectexternalCall (RexxString *, size_t, RexxExpressionStack *, RexxString *, ProtectedObject &)
 
RexxObjectinternalCall (RexxString *, RexxInstruction *, size_t, RexxExpressionStack *, ProtectedObject &)
 
RexxObjectinternalCallTrap (RexxString *, RexxInstruction *, RexxDirectory *, ProtectedObject &)
 
bool callMacroSpaceFunction (RexxString *, RexxObject **, size_t, RexxString *, int, ProtectedObject &)
 
RexxStringresolveProgramName (RexxString *name)
 
RexxClassfindClass (RexxString *name)
 
RexxObjectresolveDotVariable (RexxString *name)
 
void command (RexxString *, RexxString *)
 
int64_t getElapsed ()
 
RexxDateTime getTime ()
 
RexxIntegerrandom (RexxInteger *, RexxInteger *, RexxInteger *)
 
size_t currentLine ()
 
void arguments (RexxObject *)
 
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)
 
void traceTaggedValue (int prefix, const char *tagPrefix, bool quoteTag, RexxString *tag, const char *marker, RexxObject *value)
 
void traceOperatorValue (int prefix, const char *tag, RexxObject *value)
 
void traceSourceString ()
 
void traceClause (RexxInstruction *, int)
 
void traceEntry ()
 
void resetElapsed ()
 
RexxStringformatTrace (RexxInstruction *, RexxSource *)
 
RexxStringgetTraceBack ()
 
RexxDirectorylocal ()
 
RexxStringformatSourcelessTraceLine (RexxString *packageName)
 
RexxArraygetStackFrames (bool skipFirst)
 
void implicitExit ()
 
void unwindTrap (RexxActivation *)
 
RexxStringsourceString ()
 
void addLocalRoutine (RexxString *name, RexxMethod *method)
 
RexxDirectorygetPublicRoutines ()
 
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 ()
 
PackageClassloadRequires (RexxString *, RexxInstruction *)
 
void loadLibrary (RexxString *target, RexxInstruction *instruction)
 
RexxObjectrexxVariable (RexxString *)
 
void pushEnvironment (RexxObject *)
 
RexxObjectpopEnvironment ()
 
void processTraps ()
 
void mergeTraps (RexxQueue *, RexxQueue *)
 
uint64_t getRandomSeed (RexxInteger *)
 
void adjustRandomSeed ()
 
RexxVariableDictionarygetObjectVariables ()
 
RexxDirectorygetLabels ()
 
RexxStringgetProgramName ()
 
RexxObjectpopControl ()
 
void pushControl (RexxObject *)
 
void closeStreams ()
 
void checkTrapTable ()
 
RexxObjectresolveStream (RexxString *name, bool input, RexxString **fullName, bool *added)
 
RexxDirectorygetStreams ()
 
RexxObjectnovalueHandler (RexxString *)
 
RexxVariableBaseretriever (RexxString *)
 
RexxVariableBasedirectRetriever (RexxString *)
 
RexxObjecthandleNovalueEvent (RexxString *name, RexxObject *defaultValue, RexxVariable *variable)
 
RexxSourcegetSourceObject ()
 
RexxSourcegetEffectiveSourceObject ()
 
PackageClassgetPackage ()
 
RexxObjectgetLocalEnvironment (RexxString *name)
 
void setReturnStatus (int status)
 
void setCallType (RexxString *type)
 
void pushBlock (RexxDoBlock *block)
 
void popBlock ()
 
RexxDoBlocktopBlock ()
 
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 ()
 
RexxActivitygetActivity ()
 
RexxStringgetMessageName ()
 
RexxStringgetCallname ()
 
RexxInstructiongetCurrent ()
 
void getSettings (ActivationSettings &s)
 
void putSettings (ActivationSettings &s)
 
RexxStringgetAddress ()
 
RexxDirectorygetConditionObj ()
 
void setConditionObj (RexxDirectory *condition)
 
RexxInstructiongetNext ()
 
void setNext (RexxInstruction *v)
 
void setCurrent (RexxInstruction *v)
 
bool inDebug ()
 
RexxExpressionStackgetStack ()
 
virtual NumericSettingsgetNumericSettings ()
 
virtual RexxActivationgetRexxContext ()
 
virtual RexxActivationfindRexxContext ()
 
virtual RexxObjectgetReceiver ()
 
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)
 
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)
 
void traceResult (RexxObject *v)
 
bool tracingInstructions (void)
 
bool tracingErrors (void)
 
bool tracingFailures (void)
 
void traceInstruction (RexxInstruction *v)
 
void traceLabel (RexxInstruction *v)
 
void traceCommand (RexxInstruction *v)
 
bool tracingCommands (void)
 
bool tracingAll (void)
 
void pauseInstruction ()
 
int conditionalPauseInstruction ()
 
void pauseLabel ()
 
void pauseCommand ()
 
SecurityManagergetSecurityManager ()
 
SecurityManagergetEffectiveSecurityManager ()
 
bool isTopLevel ()
 
bool isForwarded ()
 
bool isGuarded ()
 
void setGuarded ()
 
bool isExternalTraceOn ()
 
void setExternalTraceOn ()
 
void setExternalTraceOff ()
 
void enableExternalTrace ()
 
bool isElapsedTimerReset ()
 
void setElapsedTimerInvalid ()
 
void setElapsedTimerValid ()
 
RexxObject ** getMethodArgumentList ()
 
size_t getMethodArgumentCount ()
 
RexxObjectgetMethodArgument (size_t position)
 
RexxArraygetArguments ()
 
RexxObject ** getProgramArgumentlist ()
 
size_t getProgramArgumentCount ()
 
RexxObjectgetProgramArgument (size_t position)
 
RexxObjectgetContextObject ()
 
RexxObjectgetContextLine ()
 
size_t getContextLineNumber ()
 
RexxObjectgetContextReturnStatus ()
 
StackFrameClasscreateStackFrame ()
 
RexxVariableDictionarygetLocalVariables ()
 
RexxDirectorygetAllLocalVariables ()
 
RexxVariablegetLocalVariable (RexxString *name, size_t index)
 
RexxVariablegetLocalStemVariable (RexxString *name, size_t index)
 
RexxStemgetLocalStem (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)
 
RexxObjectevaluateLocalCompoundVariable (RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
 
RexxObjectgetLocalCompoundVariableValue (RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
 
RexxObjectgetLocalCompoundVariableRealValue (RexxString *localstem, size_t index, RexxObject **tail, size_t tailCount)
 
RexxCompoundElementgetLocalCompoundVariable (RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
 
RexxCompoundElementexposeLocalCompoundVariable (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 ()
 
RexxVariablenewLocalVariable (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)
 
RexxActivationBasegetPreviousStackFrame ()
 
BaseExecutablegetExecutable ()
 
RexxObjectgetExecutableObject ()
 
- Public Member Functions inherited from RexxInternalObject
void * operator new (size_t, RexxClass *)
 
void * operator new (size_t, RexxClass *, RexxObject **, size_t)
 
void * operator new (size_t size, void *ptr)
 
void operator delete (void *)
 
void operator delete (void *p, void *ptr)
 
 RexxInternalObject ()
 
 RexxInternalObject (RESTORETYPE restoreType)
 
virtual ~RexxInternalObject ()
 
 operator RexxObject * ()
 
size_t getObjectSize ()
 
void setObjectSize (size_t s)
 
size_t getObjectDataSize ()
 
void * getObjectDataSpace ()
 
void clearObject ()
 
void clearObject (size_t l)
 
void setVirtualFunctions (void *t)
 
void setInitHeader (size_t s, size_t markword)
 
void setInitHeader (size_t markword)
 
void setObjectLive (size_t markword)
 
void setHasReferences ()
 
void setHasNoReferences ()
 
bool hasReferences ()
 
bool hasNoReferences ()
 
void setPrimitive ()
 
void setNonPrimitive ()
 
bool isPrimitive ()
 
bool isNonPrimitive ()
 
bool isObjectMarked (size_t markword)
 
void setObjectMark (size_t markword)
 
void clearObjectMark ()
 
bool isObjectLive (size_t mark)
 
bool isObjectDead (size_t mark)
 
bool isOldSpace ()
 
bool isNewSpace ()
 
void setNewSpace ()
 
void setOldSpace ()
 
void makeProxiedObject ()
 
bool isProxyObject ()
 
bool isSubClassOrEnhanced ()
 
bool isBaseClass ()
 
size_t getObjectTypeNumber ()
 
RexxBehaviourgetObjectType ()
 
bool isObjectType (RexxBehaviour *b)
 
bool isObjectType (size_t t)
 
bool isSameType (RexxInternalObject *o)
 
void setBehaviour (RexxBehaviour *b)
 
virtual RexxObjectmakeProxy (RexxEnvelope *)
 
virtual RexxObjectcopy ()
 
virtual RexxObjectevaluate (RexxActivation *, RexxExpressionStack *)
 
virtual RexxObjectgetValue (RexxActivation *)
 
virtual RexxObjectgetValue (RexxVariableDictionary *)
 
virtual RexxObjectgetRealValue (RexxActivation *)
 
virtual RexxObjectgetRealValue (RexxVariableDictionary *)
 
virtual void uninit ()
 
virtual HashCode hash ()
 
virtual HashCode getHashValue ()
 
HashCode identityHash ()
 
virtual bool truthValue (int)
 
virtual bool logicalValue (logical_t &)
 
virtual RexxStringmakeString ()
 
virtual void copyIntoTail (RexxCompoundTail *buffer)
 
virtual RexxStringprimitiveMakeString ()
 
virtual RexxArraymakeArray ()
 
virtual RexxStringstringValue ()
 
virtual RexxIntegerintegerValue (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 RexxNumberStringnumberString ()
 
virtual bool isEqual (RexxObject *)
 
virtual bool isInstanceOf (RexxClass *)
 
virtual RexxMethodinstanceMethod (RexxString *)
 
virtual RexxSupplierinstanceMethods (RexxClass *)
 
void hasUninit ()
 
void removedUninit ()
 
void printObject ()
 
RexxObjectclone ()
 
- Public Member Functions inherited from RexxVirtualBase
virtual void flatten (RexxEnvelope *)
 
virtual RexxObjectunflatten (RexxEnvelope *)
 

Static Public Member Functions

static size_t processTraceSetting (size_t traceSetting)
 
static RoutineClassgetMacroCode (RexxString *macroName)
 
- Static Public Member Functions inherited from RexxInternalObject
static size_t getObjectHeaderSize ()
 

Protected Attributes

ActivationSettings settings
 
RexxExpressionStack stack
 
RexxCodecode
 
RexxSourcesourceObject
 
RexxClassscope
 
RexxObjectreceiver
 
RexxActivityactivity
 
RexxActivationparent
 
RexxObject ** arglist
 
size_t argcount
 
RexxDoBlockdostack
 
RexxInstructioncurrent
 
RexxInstructionnext
 
bool debug_pause
 
int object_scope
 
RexxObjectresult
 
RexxArraytrapinfo
 
RexxContextcontextObject
 
int execution_state
 
int activation_context
 
RexxMessageobjnotify
 
RexxListenvironmentList
 
size_t pending_count
 
RexxQueuehandler_queue
 
RexxQueuecondition_queue
 
uint64_t random_seed
 
bool random_set
 
size_t blockNest
 
size_t lookaside_size
 
- Protected Attributes inherited from RexxActivationBase
RexxActivationBaseprevious
 
BaseExecutableexecutable
 

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 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
 
RexxBehaviourbehaviour
 
- Protected Member Functions inherited from RexxVirtualBase
virtual ~RexxVirtualBase ()
 
virtual void baseVirtual ()
 

Detailed Description

Definition at line 156 of file RexxActivation.hpp.

Constructor & Destructor Documentation

◆ RexxActivation() [1/5]

RexxActivation::RexxActivation ( RESTORETYPE  restoreType)
inline

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

References RexxInternalObject::setHasNoReferences().

◆ RexxActivation() [3/5]

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

Initialize an activation for a method invocation.

Parameters
_activityThe activity we're running under.
_methodThe method being invoked.
_codeThe code to execute.

Definition at line 158 of file RexxActivation.cpp.

References activation_context, activationSettingsTemplate, ACTIVE, activity, RexxActivity::allocateLocalVariableFrame(), RexxActivity::allocateStackFrame(), ActivationSettings::alternate_env, ActivationSettings::calltype, RexxInternalObject::clearObject(), code, ActivationSettings::current_env, NumericSettings::digits, RexxActivationBase::executable, execution_state, NumericSettings::form, NumericSettings::fuzz, InterpreterInstance::getDefaultEnvironment(), RexxSource::getDigits(), RexxSource::getForm(), RexxSource::getFuzz(), RexxActivity::getInstance(), RexxActivity::getInstanceSecurityManager(), RexxCode::getLocalVariableSize(), RexxCode::getMaxStackSize(), RexxActivity::getRandomSeed(), RexxMethod::getScope(), RexxCode::getSecurityManager(), BaseExecutable::getSourceObject(), RexxSource::getTraceFlags(), RexxSource::getTraceSetting(), RexxLocalVariables::init(), ActivationSettings::intermediate_trace, RexxMethod::isGuarded(), ActivationSettings::local_variables, METHODCALL, ActivationSettings::numericSettings, object_scope, OREF_NULL, parent, ActivationSettings::parent_code, random_seed, scope, SCOPE_RELEASED, ActivationSettings::securityManager, setGuarded(), RexxInternalObject::setHasNoReferences(), RexxInternalObject::setHasReferences(), settings, setTrace(), sourceObject, and stack.

◆ RexxActivation() [4/5]

RexxActivation::RexxActivation ( RexxActivity _activity,
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
_activityThe current thread we're running on.
_routineThe routine to invoke.
_codeThe code object to be executed.
calltypeType type of call being made (function or subroutine)
envThe default address environment
contextThe type of call context.

Definition at line 304 of file RexxActivation.cpp.

References activation_context, activationSettingsTemplate, ACTIVE, activity, adjustRandomSeed(), RexxActivity::allocateLocalVariableFrame(), RexxActivity::allocateStackFrame(), ActivationSettings::alternate_env, ActivationSettings::calltype, RexxInternalObject::clearObject(), code, ActivationSettings::current_env, NumericSettings::digits, RexxActivationBase::executable, execution_state, NumericSettings::form, NumericSettings::fuzz, InterpreterInstance::getDefaultEnvironment(), RexxSource::getDigits(), RexxSource::getForm(), RexxSource::getFuzz(), RexxActivity::getInstance(), RexxActivity::getInstanceSecurityManager(), RexxCode::getLocalVariableSize(), RexxCode::getMaxStackSize(), RexxActivity::getRandomSeed(), RexxCode::getSecurityManager(), BaseExecutable::getSourceObject(), RexxSource::getTraceFlags(), RexxSource::getTraceSetting(), RexxLocalVariables::init(), ActivationSettings::intermediate_trace, ActivationSettings::local_variables, ActivationSettings::numericSettings, object_scope, OREF_NULL, parent, ActivationSettings::parent_code, random_seed, SCOPE_RELEASED, ActivationSettings::securityManager, setDefaultAddress(), RexxInternalObject::setHasNoReferences(), RexxInternalObject::setHasReferences(), settings, setTrace(), sourceObject, and stack.

◆ 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
_activityThe current activity.
_parentThe parent activation.
_codeThe code to be executed. For interpret and debug pauses, this is a new code object. For call activations, this is the parent code object.
contextThe type of call being made.

Definition at line 231 of file RexxActivation.cpp.

References activation_context, ACTIVE, activity, adjustRandomSeed(), RexxActivity::allocateStackFrame(), RexxInternalObject::clearObject(), code, debug_pause, DEBUGPAUSE, RexxActivationBase::executable, execution_state, ActivationSettings::flags, RexxActivationBase::getExecutable(), RexxCode::getMaxStackSize(), RexxCode::getSourceObject(), BaseExecutable::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, traps_copied, and RexxDateTime::valid.

Member Function Documentation

◆ addBlock()

void RexxActivation::addBlock ( )
inline

Definition at line 341 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
nameThe name to add this under.
methodThe method associated with the name.

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

References random_seed.

Referenced by RexxActivation().

◆ arguments()

void RexxActivation::arguments ( RexxObject )

Referenced by createStackFrame().

◆ assignLocalCompoundVariable()

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

◆ cacheLocalVariable()

void RexxActivation::cacheLocalVariable ( RexxVariable var)
inline

Definition at line 564 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,
RexxString calltype,
ProtectedObject resultObj 
)

Call an external program as a function or subroutine.

Parameters
targetThe target function name.
parentThe name of the parent program (used for resolving extensions).
_argumentsThe arguments to the call.
_argcountThe count of arguments for the call.
calltypeThe type of call (FUNCTION or SUBROUTINE)
resultObjThe returned result.
Returns
True if an external program was located and called. false for any failures.

Definition at line 2668 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,
RexxString calltype,
int  order,
ProtectedObject _result 
)

Attempt to call a function stored in the macrospace.

Parameters
targetThe target function name.
argumentsThe argument pointer.
argcountThe count of arguments,
calltypeThe type of call (FUNCTION or SUBROUTINE)
orderThe macrospace order flag.
resultThe function result.
Returns
true if the macrospace function was located and called.

Definition at line 2554 of file RexxActivation.cpp.

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

Referenced by SystemInterpreter::invokeExternalFunction().

◆ checkTrapTable()

◆ cleanupLocalVariables()

◆ clearTraceSettings()

void RexxActivation::clearTraceSettings ( )
inline

◆ closeStreams()

◆ command()

◆ conditionalPauseInstruction()

int RexxActivation::conditionalPauseInstruction ( )
inline

◆ createStackFrame()

StackFrameClass * RexxActivation::createStackFrame ( )

◆ currentLine()

size_t RexxActivation::currentLine ( )

Definition at line 1184 of file RexxActivation.cpp.

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

Referenced by RexxActivity::reraiseException().

◆ debugInterpret()

◆ debugPause()

◆ debugSkip()

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

◆ digits()

◆ directRetriever()

RexxVariableBase* RexxActivation::directRetriever ( RexxString )

◆ dispatch()

RexxObject * RexxActivation::dispatch ( )
virtual

Reimplemented from RexxActivationBase.

Definition at line 372 of file RexxActivation.cpp.

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

◆ dropLocalCompoundVariable()

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

Definition at line 4242 of file RexxActivation.cpp.

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

Referenced by RexxCompoundVariable::drop().

◆ dropLocalStem()

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

Definition at line 487 of file RexxActivation.hpp.

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

Referenced by RexxStemVariable::drop().

◆ dropLocalVariable()

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

◆ enableExternalTrace()

void RexxActivation::enableExternalTrace ( )

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

Definition at line 3617 of file RexxActivation.cpp.

References DEBUG_ON, setTrace(), trace_debug, TRACE_RESULTS, and trace_results_flags.

Referenced by SysInterpreterInstance::setupProgram().

◆ evaluateLocalCompoundVariable()

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

◆ exitFrom()

◆ expose()

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

◆ exposeLocalCompoundVariable()

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

◆ external()

RexxActivation * RexxActivation::external ( )

Definition at line 1492 of file RexxActivation.cpp.

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

Referenced by external().

◆ externalCall()

RexxObject * RexxActivation::externalCall ( RexxString target,
size_t  _argcount,
RexxExpressionStack _stack,
RexxString calltype,
ProtectedObject resultObj 
)

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

Parameters
targetThe target function name.
_argcountThe count of arguments for the call.
_stackThe expression stack holding the arguments.
calltypeThe type of call (FUNCTION or SUBROUTINE)
resultObjThe returned result.
Returns
The function result (also returned in the resultObj protected object reference.

Definition at line 2597 of file RexxActivation.cpp.

References activity, RexxExpressionStack::arguments(), 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 ( )

◆ externalTraceOn()

◆ findClass()

RexxClass * RexxActivation::findClass ( RexxString name)

Resolve a class in this activation's context.

Parameters
nameThe name to resolve.
Returns
The resolved class, or OREF_NULL if not found.

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

◆ form()

bool RexxActivation::form ( )
virtual

◆ 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
packageNameThe package name to use (could be "REXX" for internal code)
Returns
A formatted descriptive string for the invocation.

Definition at line 4350 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(), and scope.

Referenced by RexxSource::traceBack().

◆ formatTrace()

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

◆ forward()

◆ fuzz()

size_t RexxActivation::fuzz ( )
virtual

◆ getActivity()

RexxActivity* RexxActivation::getActivity ( )
inline

Definition at line 351 of file RexxActivation.hpp.

References activity.

Referenced by RexxInstructionSay::execute().

◆ getAddress()

RexxString* RexxActivation::getAddress ( )
inline

Definition at line 357 of file RexxActivation.hpp.

References ActivationSettings::current_env, and settings.

Referenced by RexxInstructionCommand::execute().

◆ getAllLocalVariables()

RexxDirectory* RexxActivation::getAllLocalVariables ( )
inline

◆ getArguments()

RexxArray* RexxActivation::getArguments ( )
inline

Definition at line 434 of file RexxActivation.hpp.

References argcount, arglist, and new_array().

Referenced by createStackFrame().

◆ getCallname()

RexxString* RexxActivation::getCallname ( )
inline

◆ getConditionObj()

RexxDirectory* RexxActivation::getConditionObj ( )
inline

◆ getContextLine()

RexxObject * RexxActivation::getContextLine ( )

Return the line context information for a context.

Returns
The current execution line.

Definition at line 2486 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 2507 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 2469 of file RexxActivation.cpp.

References contextObject, and OREF_NULL.

Referenced by RexxNativeActivation::getRexxContextObject(), and rexxVariable().

◆ getContextReturnStatus()

RexxObject * RexxActivation::getContextReturnStatus ( )

Return the RS context information for a activation.

Returns
The current execution line.

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

References current.

◆ getEffectiveSecurityManager()

SecurityManager * RexxActivation::getEffectiveSecurityManager ( )

Get the security manager in used by this activation.

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

Definition at line 4271 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

◆ getElapsed()

int64_t RexxActivation::getElapsed ( )

◆ getIndent()

size_t RexxActivation::getIndent ( )
inline

◆ getLabels()

RexxDirectory * RexxActivation::getLabels ( )

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

◆ getLocalCompoundVariableRealValue()

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

◆ getLocalCompoundVariableValue()

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

◆ getLocalEnvironment()

RexxObject * RexxActivation::getLocalEnvironment ( RexxString name)

Retrieve a value from the instance local environment.

Parameters
nameThe name of the .local object.
Returns
The object stored at the given name.

Definition at line 4289 of file RexxActivation.cpp.

References activity, and RexxActivity::getLocalEnvironment().

Referenced by novalueHandler(), and resolveStream().

◆ getLocalStem()

◆ getLocalStemVariable()

◆ getLocalVariable()

◆ getLocalVariables()

RexxVariableDictionary* RexxActivation::getLocalVariables ( )
inline

◆ getMacroCode()

RoutineClass * RexxActivation::getMacroCode ( RexxString macroName)
static

Retrieve a macro image file from the macro space.

Parameters
macroNameThe name of the macro to retrieve.
Returns
If available, the unflattened method image.

Definition at line 2714 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

◆ getMethodArgument()

RexxObject* RexxActivation::getMethodArgument ( size_t  position)
inline

◆ getMethodArgumentCount()

size_t RexxActivation::getMethodArgumentCount ( )
inline

◆ getMethodArgumentList()

RexxObject** RexxActivation::getMethodArgumentList ( )
inline

◆ getNext()

RexxInstruction* RexxActivation::getNext ( )
inline

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

References ActivationSettings::numericSettings, and settings.

Referenced by RexxNativeActivation::getNumericSettings().

◆ getObjectVariables()

◆ getPackage()

PackageClass * RexxActivation::getPackage ( )

Retrieve the package for the current execution context.

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

Definition at line 4139 of file RexxActivation.cpp.

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

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

◆ getProgramArgument()

RexxObject* RexxActivation::getProgramArgument ( size_t  position)
inline

◆ getProgramArgumentCount()

size_t RexxActivation::getProgramArgumentCount ( )
inline

◆ getProgramArgumentlist()

RexxObject** RexxActivation::getProgramArgumentlist ( )
inline

Definition at line 436 of file RexxActivation.hpp.

References ActivationSettings::parent_arglist, and settings.

◆ getProgramName()

RexxString * RexxActivation::getProgramName ( )

Definition at line 3967 of file RexxActivation.cpp.

References code, and RexxCode::getProgramName().

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

References code, and RexxCode::getPublicRoutines().

◆ getRandomSeed()

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

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

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

◆ 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 1996 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 4259 of file RexxActivation.cpp.

References ActivationSettings::securityManager, and settings.

◆ getSettings()

void RexxActivation::getSettings ( ActivationSettings s)
inline

Definition at line 355 of file RexxActivation.hpp.

References settings.

Referenced by run().

◆ getSourceObject()

◆ getStack()

RexxExpressionStack* RexxActivation::getStack ( )
inline

Definition at line 365 of file RexxActivation.hpp.

References stack.

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

◆ getStackFrames()

RexxArray * RexxActivation::getStackFrames ( bool  skipFirst)

Generate the stack frames for the current context.

Returns
A list of the stackframes.

Definition at line 4382 of file RexxActivation.cpp.

References activity, and RexxActivity::generateStackFrames().

Referenced by RexxContext::getStackFrames().

◆ getStreams()

◆ getTime()

◆ getTraceBack()

RexxString * RexxActivation::getTraceBack ( )

Get a traceback line for the current instruction.

Returns
The formatted string traceback.

Definition at line 2925 of file RexxActivation.cpp.

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

Referenced by createStackFrame().

◆ guardOff()

◆ guardOn()

◆ guardWait()

◆ halt()

bool RexxActivation::halt ( RexxString description)

Halt the activation

Parameters
descriptionThe 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 3632 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
nameThe variable name triggering the event.
variableThe resolved variable object for the variable.
Returns
A value for that variable.

Definition at line 2250 of file RexxActivation.cpp.

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

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

◆ hasActiveBlocks()

bool RexxActivation::hasActiveBlocks ( )
inline

Definition at line 342 of file RexxActivation.hpp.

References blockNest.

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

◆ implicitExit()

void RexxActivation::implicitExit ( )
inline

◆ inDebug()

bool RexxActivation::inDebug ( )
inline

◆ indent()

◆ inMethod()

◆ internalCall()

RexxObject * RexxActivation::internalCall ( RexxString name,
RexxInstruction target,
size_t  _argcount,
RexxExpressionStack _stack,
ProtectedObject returnObject 
)

Process an internal function or subroutine call.

Parameters
nameThe name of the target label.
targetThe target instruction where we start executing (this is the label)
_argcountThe count of arguments
_stackThe context stack holding the arguments
returnObjectA holder for the return value
Returns
The return value object

Definition at line 2844 of file RexxActivation.cpp.

References activity, RexxExpressionStack::arguments(), current, RexxInstruction::getLineNumber(), INTERNALCALL, new_integer(), ActivityManager::newActivation(), 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
nameThe label name of the internal call.
targetThe target instruction for the call (the label)
conditionObjThe associated condition object
resultObjA holder for a result object
Returns
Any return result

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

◆ isElapsedTimerReset()

bool RexxActivation::isElapsedTimerReset ( )
inline

Definition at line 418 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by getTime().

◆ isExternalTraceOn()

bool RexxActivation::isExternalTraceOn ( )
inline

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

References ActivationSettings::flags, forwarded, and settings.

Referenced by RexxActivity::raiseException().

◆ isGuarded()

bool RexxActivation::isGuarded ( )
inline

Definition at line 410 of file RexxActivation.hpp.

References ActivationSettings::flags, guarded_method, and settings.

Referenced by getObjectVariables(), and run().

◆ isInternalCall()

bool RexxActivation::isInternalCall ( )
inline

Definition at line 198 of file RexxActivation.hpp.

References activation_context, and INTERNALCALL.

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

◆ isInternalLevelCall()

bool RexxActivation::isInternalLevelCall ( )
inline

Definition at line 204 of file RexxActivation.hpp.

References activation_context, and INTERNAL_LEVEL_CALL.

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

◆ isInterpret()

◆ isMethod()

bool RexxActivation::isMethod ( )
inline

◆ isMethodOrRoutine()

bool RexxActivation::isMethodOrRoutine ( )
inline

Definition at line 206 of file RexxActivation.hpp.

References isMethod(), and isRoutine().

Referenced by run().

◆ isProgram()

bool RexxActivation::isProgram ( )
inline

Definition at line 201 of file RexxActivation.hpp.

References activation_context, and PROGRAMCALL.

Referenced by createStackFrame().

◆ isProgramLevelCall()

bool RexxActivation::isProgramLevelCall ( )
inline

Definition at line 203 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 205 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 2019 of file RexxActivation.cpp.

◆ isRoutine()

bool RexxActivation::isRoutine ( )
inline

◆ isTopLevel()

bool RexxActivation::isTopLevel ( )
inline

Definition at line 408 of file RexxActivation.hpp.

References activation_context, and TOP_LEVEL_CALL.

Referenced by exitFrom().

◆ isTopLevelCall()

bool RexxActivation::isTopLevelCall ( )
inline

Definition at line 202 of file RexxActivation.hpp.

References activation_context, and TOP_LEVEL_CALL.

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

◆ iterate()

◆ leaveLoop()

◆ live()

◆ liveGeneral()

◆ loadLibrary()

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

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

Parameters
targetThe name of the package.
instructionThe ::REQUIRES directive being loaded.

Definition at line 2823 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
targetThe name of the ::REQUIRES
instructionThe directive instruction being processed.

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

◆ localStemVariableExists()

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

◆ localVariableExists()

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

◆ mergeTraps()

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

◆ newDo()

void RexxActivation::newDo ( RexxDoBlock block)
inline

◆ newLocalVariable()

◆ novalueEnabled()

bool RexxActivation::novalueEnabled ( )
inline

◆ novalueHandler()

RexxObject * RexxActivation::novalueHandler ( RexxString name)

◆ operator delete() [1/2]

void RexxActivation::operator delete ( void *  )
inline

Definition at line 161 of file RexxActivation.hpp.

◆ operator delete() [2/2]

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

Definition at line 162 of file RexxActivation.hpp.

◆ operator new() [1/2]

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

Definition at line 160 of file RexxActivation.hpp.

◆ operator new() [2/2]

void * RexxActivation::operator new ( size_t  size)

Definition at line 131 of file RexxActivation.cpp.

References new_object(), and T_Activation.

◆ pauseCommand()

void RexxActivation::pauseCommand ( )
inline

◆ pauseInstruction()

◆ pauseLabel()

void RexxActivation::pauseLabel ( )
inline

◆ popBlock()

void RexxActivation::popBlock ( )
inline

◆ popControl()

RexxObject* RexxActivation::popControl ( )

◆ popEnvironment()

RexxObject * RexxActivation::popEnvironment ( )

◆ procedureExpose()

◆ processClauseBoundary()

◆ processTraceSetting()

size_t RexxActivation::processTraceSetting ( size_t  traceSetting)
static

◆ processTraps()

◆ propagateExit()

void RexxActivation::propagateExit ( RexxObject )

◆ pushBlock()

void RexxActivation::pushBlock ( RexxDoBlock block)
inline

Definition at line 334 of file RexxActivation.hpp.

References dostack, and RexxDoBlock::setPrevious().

Referenced by newDo().

◆ pushControl()

void RexxActivation::pushControl ( RexxObject )

◆ pushEnvironment()

void RexxActivation::pushEnvironment ( RexxObject environment)

◆ putLocalVariable()

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

◆ putSettings()

void RexxActivation::putSettings ( ActivationSettings s)
inline

Definition at line 356 of file RexxActivation.hpp.

References settings.

Referenced by RexxActivation(), and unwindTrap().

◆ raise()

◆ raiseExit()

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

◆ random()

◆ removeBlock()

void RexxActivation::removeBlock ( )
inline

◆ reply()

void RexxActivation::reply ( RexxObject resultObj)

◆ resetElapsed()

void RexxActivation::resetElapsed ( )

Definition at line 2979 of file RexxActivation.cpp.

References setElapsedTimerInvalid().

◆ resolveDotVariable()

RexxObject * RexxActivation::resolveDotVariable ( RexxString name)

Resolve a class in this activation's context.

Parameters
nameThe name to resolve.
Returns
The resolved class, or OREF_NULL if not found.

Definition at line 2781 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
nameThe name to resolve.
Returns
The fully resolved program name, or OREF_NULL if this can't be located.

Definition at line 2749 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
nameThe name of the stream.
stackThe expression stack.
inputThe input/output flag.
fullNameThe returned full name of the stream.
addedA flag indicating we added this.
Returns
The backing stream object for the name.

Definition at line 1686 of file RexxActivation.cpp.

References RexxDirectory::at(), CHAR_CSTDERR, CHAR_CSTDIN, CHAR_CSTDOUT, CHAR_STDERR, CHAR_STDIN, CHAR_STDOUT, 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()

◆ rexxVariable()

◆ run() [1/2]

RexxObject* RexxActivation::run ( RexxObject **  _arglist,
size_t  _argcount,
ProtectedObject _result 
)
inline

Definition at line 210 of file RexxActivation.hpp.

References OREF_NULL, and run().

◆ run() [2/2]

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

Definition at line 383 of file RexxActivation.cpp.

References ACTIVE, activity, RexxActivity::allocateFrame(), argcount, arglist, RexxActivity::callInitializationExit(), RexxMemory::checkUninitQueue(), clause_boundary, clause_exits, RexxExpressionStack::clear(), RexxLocalVariables::clearNested(), code, condition_queue, current, debug_pause, RexxInstruction::execute(), execution_state, ActivationSettings::flags, RexxCode::getFirstInstruction(), RexxExpressionStack::getFrame(), RexxActivity::getInstance(), RexxObject::getObjectVariables(), getSettings(), RexxList::getSize(), handler_queue, Interpreter::hasTimeSliceElapsed(), implicitExit(), RexxCode::install(), RexxActivity::isClauseExitUsed(), isGuarded(), isInternalCall(), isInterpret(), isMethodOrRoutine(), RexxLocalVariables::isNested(), RexxInternalObject::isOldSpace(), isProgramLevelCall(), isTopLevelCall(), RexxInstruction::isType(), KEYWORD_LABEL, KEYWORD_PROCEDURE, ActivationSettings::local_variables, MAX_INSTRUCTIONS, memoryObject, mergeTraps(), RexxExpressionStack::migrate(), RexxLocalVariables::migrate(), ActivationSettings::msgname, next, RexxInstruction::nextInstruction, object_scope, ActivationSettings::object_variables, OREF_NULL, parent, ActivationSettings::parent_argcount, ActivationSettings::parent_arglist, pending_count, RexxActivity::popStackFrame(), procedure_valid, processClauseBoundary(), processTraps(), RexxActivity::pushStackFrame(), receiver, RexxActivity::releaseStackFrame(), RexxActivity::relinquish(), REPLIED, RexxVariableDictionary::reserve(), result, RETURNED, RexxActivity::run(), scope, SCOPE_RESERVED, setLocalVariable(), settings, InterpreterInstance::setupProgram(), RexxActivity::spawnReply(), stack, RexxObject::superScope(), termination(), ActivationSettings::timestamp, traceEntry(), tracingAll(), RexxVariableDictionary::transfer(), transfer_failed, RexxActivity::unwindToFrame(), RexxDateTime::valid, VARIABLE_SELF, and VARIABLE_SUPER.

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

◆ senderActivation()

RexxActivation * RexxActivation::senderActivation ( )

Definition at line 2337 of file RexxActivation.cpp.

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

Referenced by raise().

◆ setAddress()

void RexxActivation::setAddress ( RexxString address)

◆ setCallType()

void RexxActivation::setCallType ( RexxString type)
inline

Definition at line 333 of file RexxActivation.hpp.

References ActivationSettings::calltype, settings, and type.

◆ setConditionObj()

void RexxActivation::setConditionObj ( RexxDirectory condition)
inline

◆ setCurrent()

void RexxActivation::setCurrent ( RexxInstruction v)
inline

Definition at line 362 of file RexxActivation.hpp.

References current.

Referenced by ClassDirective::install().

◆ setDefaultAddress()

void RexxActivation::setDefaultAddress ( RexxString address)

◆ setDigits() [1/2]

void RexxActivation::setDigits ( )

Set the digits setting to the package-defined default

Definition at line 1940 of file RexxActivation.cpp.

References RexxSource::getDigits(), and sourceObject.

◆ setDigits() [2/2]

void RexxActivation::setDigits ( size_t  digitsVal)
virtual

◆ setElapsedTimerInvalid()

void RexxActivation::setElapsedTimerInvalid ( )
inline

Definition at line 419 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by resetElapsed().

◆ setElapsedTimerValid()

void RexxActivation::setElapsedTimerValid ( )
inline

Definition at line 420 of file RexxActivation.hpp.

References elapsed_reset, ActivationSettings::flags, and settings.

Referenced by getTime().

◆ setExternalTraceOff()

void RexxActivation::setExternalTraceOff ( )
inline

Definition at line 415 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_on.

Referenced by processClauseBoundary().

◆ setExternalTraceOn()

void RexxActivation::setExternalTraceOn ( )
inline

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

References RexxSource::getForm(), and sourceObject.

◆ setForm() [2/2]

void RexxActivation::setForm ( bool  formVal)
virtual

◆ setFuzz() [1/2]

void RexxActivation::setFuzz ( )

Set the fuzz setting to the package-defined default

Definition at line 1956 of file RexxActivation.cpp.

References RexxSource::getFuzz(), and sourceObject.

◆ setFuzz() [2/2]

void RexxActivation::setFuzz ( size_t  fuzzVal)
virtual

◆ setGuarded()

void RexxActivation::setGuarded ( )
inline

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

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

Referenced by RexxCompoundVariable::set().

◆ setLocalVariable()

◆ setLocalVariableDictionary()

void RexxActivation::setLocalVariableDictionary ( RexxVariableDictionary dict)
inline

◆ setNext()

◆ setObjNotify()

void RexxActivation::setObjNotify ( RexxMessage notify)
virtual

Reimplemented from RexxActivationBase.

Definition at line 4029 of file RexxActivation.cpp.

References objnotify.

◆ setReturnStatus()

void RexxActivation::setReturnStatus ( int  status)

Set the return status flag for an activation context.

Parameters
statusThe new status value.

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

Set the trace using a dynamically evaluated string.

Parameters
settingThe new trace setting.

Definition at line 749 of file RexxActivation.cpp.

References Error_Invalid_trace_trace, new_string(), RexxSource::parseTraceSetting(), reportException(), and setTrace().

◆ setTrace() [2/2]

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

◆ signalTo()

◆ signalValue()

void RexxActivation::signalValue ( RexxString name)

◆ sourceString()

◆ terminateBlock() [1/2]

void RexxActivation::terminateBlock ( )
inline

◆ terminateBlock() [2/2]

void RexxActivation::terminateBlock ( size_t  _indent)
inline

◆ termination()

◆ toggleAddress()

void RexxActivation::toggleAddress ( )

◆ topBlock()

RexxDoBlock* RexxActivation::topBlock ( )
inline

Definition at line 336 of file RexxActivation.hpp.

References dostack.

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

◆ traceAssignment()

◆ traceClause()

◆ traceCommand()

void RexxActivation::traceCommand ( RexxInstruction v)
inline

◆ traceCompound()

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

◆ traceCompoundAssignment()

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

◆ traceCompoundName() [1/2]

◆ traceCompoundName() [2/2]

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

◆ traceCompoundValue() [1/2]

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

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

Parameters
prefixThe trace prefix tag to use.
stemThe stem name of the compound.
tailsThe array of tail elements (unresolved).
tailCountThe count of tail elements.
valueThe associated trace value.

Definition at line 3414 of file RexxActivation.cpp.

References activity, code, ActivationSettings::flags, RexxCompoundTail::getLength(), RexxString::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
prefixThe trace prefix tag to use.
stemThe stem name of the compound.
tailsThe array of tail elements (unresolved).
tailCountThe count of tail elements.
valueThe resolved tail element

Definition at line 3397 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

◆ traceEntry()

◆ traceFunction()

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

◆ traceInstruction()

◆ traceIntermediate()

◆ traceLabel()

void RexxActivation::traceLabel ( RexxInstruction v)
inline

◆ traceMessage()

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

◆ traceOperator()

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

◆ traceOperatorValue()

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

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

Parameters
prefixThe trace prefix tag to use.
tagPrefixAny prefix string added to the tag. Use mostly for adding the "." to traced environment variables.
quoteTagIndicates whether the tag should be quoted or not. Operator names are quoted.
tagThe tag name.
valueThe associated trace value.

Definition at line 3323 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

◆ traceResult()

◆ traceSetting()

RexxString * RexxActivation::traceSetting ( )

◆ traceSourceString()

◆ traceTaggedValue()

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

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

Parameters
prefixThe trace prefix tag to use.
tagPrefixAny prefix string added to the tag. Use mostly for adding the "." to traced environment variables.
quoteTagIndicates whether the tag should be quoted or not. Operator names are quoted.
tagThe tag name.
valueThe associated trace value.

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

◆ traceVariable()

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

◆ tracingAll()

bool RexxActivation::tracingAll ( void  )
inline

Definition at line 400 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 399 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 394 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_errors.

Referenced by command().

◆ tracingFailures()

bool RexxActivation::tracingFailures ( void  )
inline

Definition at line 395 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_failures.

Referenced by command().

◆ tracingInstructions()

bool RexxActivation::tracingInstructions ( void  )
inline

Definition at line 393 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_all.

Referenced by RexxInstructionAssignment::execute().

◆ tracingIntermediates()

bool RexxActivation::tracingIntermediates ( )
inline

◆ tracingResults()

bool RexxActivation::tracingResults ( )
inline

Definition at line 350 of file RexxActivation.hpp.

References ActivationSettings::flags, settings, and trace_results.

Referenced by RexxTrigger::parse().

◆ trap()

◆ trapDelay()

void RexxActivation::trapDelay ( RexxString condition)

◆ trapOff()

◆ trapOn()

◆ trapState()

RexxString * RexxActivation::trapState ( RexxString condition)

◆ trapUndelay()

void RexxActivation::trapUndelay ( RexxString condition)

◆ unindent()

void RexxActivation::unindent ( )
inline

◆ unwindTrap()

void RexxActivation::unwindTrap ( RexxActivation child)

◆ updateLocalVariable()

void RexxActivation::updateLocalVariable ( RexxVariable variable)
inline

◆ yield()

void RexxActivation::yield ( )

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

Member Data Documentation

◆ activation_context

◆ activity

◆ argcount

size_t RexxActivation::argcount
protected

◆ arglist

RexxObject** RexxActivation::arglist
protected

◆ blockNest

size_t RexxActivation::blockNest
protected

◆ clause_boundary

const size_t RexxActivation::clause_boundary = 0x00010000
staticprotected

◆ clause_exits

const size_t RexxActivation::clause_exits = 0x00100000
staticprotected

Definition at line 660 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and run().

◆ code

◆ condition_queue

RexxQueue* RexxActivation::condition_queue
protected

Definition at line 626 of file RexxActivation.hpp.

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

◆ contextObject

RexxContext* RexxActivation::contextObject
protected

Definition at line 615 of file RexxActivation.hpp.

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

◆ current

◆ debug_bypass

const size_t RexxActivation::debug_bypass = 0x00004000
staticprotected

Definition at line 654 of file RexxActivation.hpp.

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

◆ debug_pause

bool RexxActivation::debug_pause
protected

◆ debug_prompt_issued

const size_t RexxActivation::debug_prompt_issued = 0x00002000
staticprotected

Definition at line 653 of file RexxActivation.hpp.

Referenced by debugPause(), and setTrace().

◆ default_trace_flags

const size_t RexxActivation::default_trace_flags = trace_failures
staticprotected

Definition at line 646 of file RexxActivation.hpp.

Referenced by RexxSource::translate().

◆ dostack

RexxDoBlock* RexxActivation::dostack
protected

◆ elapsed_reset

const size_t RexxActivation::elapsed_reset = 0x20000000
staticprotected

◆ environmentList

RexxList* RexxActivation::environmentList
protected

Definition at line 622 of file RexxActivation.hpp.

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

◆ execution_state

int RexxActivation::execution_state
protected

◆ external_yield

const size_t RexxActivation::external_yield = 0x00200000
staticprotected

Definition at line 661 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and yield().

◆ forwarded

const size_t RexxActivation::forwarded = 0x00400000
staticprotected

Definition at line 662 of file RexxActivation.hpp.

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

◆ guarded_method

const size_t RexxActivation::guarded_method = 0x40000000
staticprotected

Definition at line 671 of file RexxActivation.hpp.

Referenced by isGuarded(), and setGuarded().

◆ halt_condition

const size_t RexxActivation::halt_condition = 0x00020000
staticprotected

Definition at line 657 of file RexxActivation.hpp.

Referenced by halt(), and processClauseBoundary().

◆ handler_queue

RexxQueue* RexxActivation::handler_queue
protected

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

◆ next

RexxInstruction* RexxActivation::next
protected

◆ object_scope

int RexxActivation::object_scope
protected

◆ objnotify

RexxMessage* RexxActivation::objnotify
protected

Definition at line 620 of file RexxActivation.hpp.

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

◆ parent

◆ pending_count

size_t RexxActivation::pending_count
protected

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

Referenced by procedureExpose(), and run().

◆ random_seed

uint64_t RexxActivation::random_seed
protected

Definition at line 627 of file RexxActivation.hpp.

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

◆ random_set

bool RexxActivation::random_set
protected

Definition at line 628 of file RexxActivation.hpp.

◆ receiver

◆ reply_issued

const size_t RexxActivation::reply_issued = 0x00800000
staticprotected

Definition at line 663 of file RexxActivation.hpp.

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

◆ result

RexxObject* RexxActivation::result
protected

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

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

◆ scope

RexxClass* RexxActivation::scope
protected

◆ set_trace_off

const size_t RexxActivation::set_trace_off = 0x02000000
staticprotected

Definition at line 665 of file RexxActivation.hpp.

Referenced by externalTraceOff(), and processClauseBoundary().

◆ set_trace_on

const size_t RexxActivation::set_trace_on = 0x01000000
staticprotected

Definition at line 664 of file RexxActivation.hpp.

Referenced by externalTraceOn(), and processClauseBoundary().

◆ settings

ActivationSettings RexxActivation::settings
protected

Definition at line 598 of file RexxActivation.hpp.

Referenced by addLocalRoutine(), callExternalRexx(), checkTrapTable(), cleanupLocalVariables(), clearTraceSettings(), closeStreams(), conditionalPauseInstruction(), debugInterpret(), debugPause(), debugSkip(), digits(), dispatch(), exitFrom(), externalCall(), externalTraceOff(), externalTraceOn(), form(), formatTrace(), forward(), fuzz(), getAddress(), getCallname(), getConditionObj(), getContextReturnStatus(), getEffectiveSecurityManager(), getElapsed(), getIndent(), getLocalStemVariable(), getLocalVariable(), getLocalVariables(), getMessageName(), getNumericSettings(), getObjectVariables(), getProgramArgument(), getProgramArgumentCount(), getProgramArgumentlist(), 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(), 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(), 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 651 of file RexxActivation.hpp.

◆ single_step_nested

const size_t RexxActivation::single_step_nested = 0x00001000
staticprotected

Definition at line 652 of file RexxActivation.hpp.

◆ source_traced

const size_t RexxActivation::source_traced = 0x00080000
staticprotected

Definition at line 659 of file RexxActivation.hpp.

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

◆ sourceObject

RexxSource* RexxActivation::sourceObject
protected

◆ stack

◆ trace_all

const size_t RexxActivation::trace_all = 0x00000002
staticprotected

◆ trace_all_flags

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

Definition at line 647 of file RexxActivation.hpp.

◆ trace_commands

const size_t RexxActivation::trace_commands = 0x00000010
staticprotected

◆ trace_debug

◆ trace_errors

const size_t RexxActivation::trace_errors = 0x00000040
staticprotected

Definition at line 642 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and tracingErrors().

◆ trace_failures

const size_t RexxActivation::trace_failures = 0x00000080
staticprotected

Definition at line 643 of file RexxActivation.hpp.

Referenced by processTraceSetting(), and tracingFailures().

◆ trace_flags

const size_t RexxActivation::trace_flags = 0x000001ff
staticprotected

Definition at line 645 of file RexxActivation.hpp.

Referenced by clearTraceSettings(), and setTrace().

◆ trace_intermediates

const size_t RexxActivation::trace_intermediates = 0x00000008
staticprotected

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

◆ trace_labels

const size_t RexxActivation::trace_labels = 0x00000020
staticprotected

Definition at line 641 of file RexxActivation.hpp.

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

◆ trace_off

const size_t RexxActivation::trace_off = 0x00000000
staticprotected

Definition at line 635 of file RexxActivation.hpp.

Referenced by processClauseBoundary(), and processTraceSetting().

◆ trace_on

const size_t RexxActivation::trace_on = 0x00040000
staticprotected

Definition at line 658 of file RexxActivation.hpp.

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

◆ trace_results

const size_t RexxActivation::trace_results = 0x00000004
staticprotected

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

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

◆ trace_suppress

const size_t RexxActivation::trace_suppress = 0x00000100
staticprotected

◆ transfer_failed

const size_t RexxActivation::transfer_failed = 0x10000000
staticprotected

Definition at line 668 of file RexxActivation.hpp.

Referenced by run().

◆ trapinfo

RexxArray* RexxActivation::trapinfo
protected

Definition at line 614 of file RexxActivation.hpp.

Referenced by live(), and liveGeneral().

◆ traps_copied

const size_t RexxActivation::traps_copied = 0x04000000
staticprotected

Definition at line 666 of file RexxActivation.hpp.

Referenced by checkTrapTable(), and RexxActivation().


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