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)  

RexxActivity.hpp
Go to the documentation of this file.
1 /*----------------------------------------------------------------------------*/
2 /* */
3 /* Copyright (c) 1995, 2004 IBM Corporation. All rights reserved. */
4 /* Copyright (c) 2005-2009 Rexx Language Association. All rights reserved. */
5 /* */
6 /* This program and the accompanying materials are made available under */
7 /* the terms of the Common Public License v1.0 which accompanies this */
8 /* distribution. A copy is also available at the following address: */
9 /* http://www.oorexx.org/license.html */
10 /* */
11 /* Redistribution and use in source and binary forms, with or */
12 /* without modification, are permitted provided that the following */
13 /* conditions are met: */
14 /* */
15 /* Redistributions of source code must retain the above copyright */
16 /* notice, this list of conditions and the following disclaimer. */
17 /* Redistributions in binary form must reproduce the above copyright */
18 /* notice, this list of conditions and the following disclaimer in */
19 /* the documentation and/or other materials provided with the distribution. */
20 /* */
21 /* Neither the name of Rexx Language Association nor the names */
22 /* of its contributors may be used to endorse or promote products */
23 /* derived from this software without specific prior written permission. */
24 /* */
25 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
26 /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
27 /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
28 /* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
29 /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
30 /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
31 /* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */
32 /* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */
33 /* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */
34 /* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
35 /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
36 /* */
37 /*----------------------------------------------------------------------------*/
38 /******************************************************************************/
39 /* REXX Kernel RexxActivity.hpp */
40 /* */
41 /* Primitive Activity Class Definitions */
42 /* */
43 /******************************************************************************/
44 #ifndef Included_RexxActivity
45 #define Included_RexxActivity
46 
47 #include "ListClass.hpp"
48 #include "RexxInternalStack.hpp"
49 #include "RexxActivationStack.hpp"
50 #include "ExpressionStack.hpp"
51 #include "RexxInternalStack.hpp"
52 #include "RexxLocalVariables.hpp"
53 #include "SourceLocation.hpp"
54 #include "ExitHandler.hpp"
56 #include "SysActivity.hpp"
57 
58 
59 
60 class ProtectedObject; // needed for look aheads
61 class RexxSource;
62 class RexxMethod;
64 class ActivityDispatcher;
65 class CallbackDispatcher;
66 class TrappingDispatcher;
67 class CommandHandler;
68 class ActivationFrame;
69 
70  /* interface values for the */
71  /* activity_queue method */
72 #define QUEUE_FIFO 1
73 #define QUEUE_LIFO 2
74 
75 /******************************************************************************/
76 /* Constants used for trace prefixes */
77 /******************************************************************************/
78 
95 };
96 
97 
98 // marker used for tagged traces to separate tag from the value
99 #define VALUE_MARKER " => "
100 // marker used for tagged traces to separate tag from the value
101 #define ASSIGNMENT_MARKER " <= "
102 
103 
104 #define MAX_TRACEBACK_LIST 80 /* 40 messages are displayed */
105 #define MAX_TRACEBACK_INDENT 20 /* 10 messages are indented */
106 
107 
108 typedef enum
109 {
110  RecursiveStringError, // a recursion problem in error handling
111  FatalError, // bad problem
112  UnhandledCondition // we had an unhandled condition.
114 
115 // used only internally, can be moved to a differnet value, if the using code is adapted accordingly
116 #define LAST_EXIT (RXNOOFEXITS - 1) /* top bound of the exits */
117 
118  /* NOTE: The following object */
119  /* definitions are only included in */
120  /* a module if the define */
121  /* INCL_ACTIVITY_DEFINITIONS is used */
122  /* since they include data types that*/
123  /* are not generally required (or */
124  /* available in other classes that */
125  /* might be using the activity class */
126  /* methods */
128  friend class ProtectedObject;
129  friend class ActivationFrame;
130  public:
131  void *operator new(size_t);
132  inline void *operator new(size_t size, void *ptr) {return ptr;};
133  inline void operator delete(void *) { ; }
134  inline void operator delete(void *, void *) { ; }
135 
136  inline RexxActivity(RESTORETYPE restoreType) { ; };
137  RexxActivity();
138  RexxActivity(bool);
139 
140  void reset();
141  void runThread();
144  wholenumber_t errorNumber(RexxDirectory *conditionObject);
145  wholenumber_t displayCondition(RexxDirectory *conditionObject);
152  void reportAnException(wholenumber_t, const char *);
153  void reportAnException(wholenumber_t, const char *, const char *);
154  void reportAnException(wholenumber_t, RexxObject *, const char *);
156  void reportAnException(wholenumber_t, const char *, RexxObject *);
157  void reportAnException(wholenumber_t, const char *, wholenumber_t);
168  void reportAnException(wholenumber_t, const char *, RexxObject *, const char *, RexxObject *);
175  void live(size_t);
176  void liveGeneral(int reason);
177  void flatten(RexxEnvelope *);
178  void run();
179  void run(RexxMessage *target);
180  void checkActivationStack();
181  void updateFrameMarkers();
182  void pushStackFrame(RexxActivationBase *new_activation);
184  void popStackFrame(bool reply);
186  void unwindStackFrame();
187  void unwindToDepth(size_t depth);
188  void unwindToFrame(RexxActivation *frame);
189  void cleanupStackFrame(RexxActivationBase *poppedStackFrame);
190  RexxArray *generateStackFrames(bool skipFirst);
192 
193  void exitKernel();
194  void enterKernel();
195  RexxObject *previous();
196  void waitReserve(RexxObject *);
197  void guardWait();
198  void guardPost();
199  void guardSet();
200  void checkDeadLock(RexxActivity *);
201  void postDispatch();
202  void kill(RexxDirectory *);
203  void joinKernelQueue();
204  void relinquish();
205  bool halt(RexxString *);
206  bool setTrace(bool);
207  void yieldControl();
208  void yield();
209  void releaseAccess();
210  void requestAccess();
211  void checkStackSpace();
213  void terminatePoolActivity();
215  bool isThread(thread_id_t id) { return currentThread.equals(id); }
216  inline bool isClauseExitUsed() { return clauseExitUsed; }
217  void queryTrcHlt();
218  bool callExit(RexxActivation * activation, const char *exitName, int function, int subfunction, void *exitbuffer);
230  bool callPushExit(RexxActivation *, RexxString *, int);
235  bool callTraceTestExit(RexxActivation *, bool);
240  void queue(RexxActivation *, RexxString *, int);
246  void setupAttachedActivity(InterpreterInstance *interpreter);
247  void addToInstance(InterpreterInstance *interpreter);
248  void detachInstance();
249  void detachThread();
251 
252  inline void nestAttach() { attachCount++; }
253  inline bool isNestedAttach() { return attachCount != 0; }
254  inline void returnAttach() { attachCount--; }
255  inline void activate() { nestedCount++; }
256  inline void deactivate() { nestedCount--; }
257  inline bool isActive() { return nestedCount > 0; }
258  inline bool isInactive() { return nestedCount == 0; }
259  inline size_t getActivationLevel() { return nestedCount; }
260  inline void restoreActivationLevel(size_t l) { nestedCount = l; }
261  inline bool isSuspended() { return suspended; }
262  inline void setSuspended(bool s) { suspended = s; }
263  inline bool isInterpreterRoot() { return interpreterRoot; }
264  inline void setInterpreterRoot() { interpreterRoot = true; }
267  inline bool isAttached() { return attached; }
268  void validateThread();
269 
272  void inheritSettings(RexxActivity *parent);
273  void setupExits();
274  void enterCurrentThread();
275  void exitCurrentThread();
276  void run(ActivityDispatcher &target);
277  void run(CallbackDispatcher &target);
278  void run(TrappingDispatcher &target);
279 
282  inline size_t getActivationDepth() { return stackFrameDepth; }
284  inline RexxObject *runningRequires(RexxString *program) {return this->requiresTable->stringGet(program);}
285  inline void addRunningRequires(RexxString *program) { this->requiresTable->stringAdd((RexxObject *)program, program);}
286  inline void removeRunningRequires(RexxObject *program) {this->requiresTable->remove(program);}
287  inline void resetRunningRequires() {this->requiresTable->reset();}
288  inline bool checkRequires(RexxString *n) { return runningRequires(n) != OREF_NULL; }
289  inline void waitForDispatch() { runsem.wait(); }
290  inline void clearWait() { runsem.reset(); }
291  inline uint64_t getRandomSeed() { return randomSeed; }
292  inline void setRandomSeed(uint64_t seed) { randomSeed = seed; };
295 
298 
299  inline void allocateStackFrame(RexxExpressionStack *stack, size_t entries)
300  {
301  stack->setFrame(frameStack.allocateFrame(entries), entries);
302  }
303 
304  inline RexxObject **allocateFrame(size_t entries)
305  {
306  return frameStack.allocateFrame(entries);
307  }
308 
309  inline void releaseStackFrame(RexxObject **frame)
310  {
311  frameStack.releaseFrame(frame);
312  }
313 
315  {
316  locals->setFrame(frameStack.allocateFrame(locals->size));
317  }
318 
321  void setExitHandler(int exitNum, REXXPFN e) { getExitHandler(exitNum).setEntryPoint(e); }
322  void setExitHandler(int exitNum, const char *e) { getExitHandler(exitNum).resolve(e); }
326  void createCallContext(CallContext &context, RexxNativeActivation *owner);
327  void createExitContext(ExitContext &context, RexxNativeActivation *owner);
331 
332  static void initializeThreadContext();
333 
334  protected:
335 
336  ExitHandler &getExitHandler(int exitNum) { return sysexits[exitNum - 1]; }
337  inline bool isExitEnabled(int exitNum) { return getExitHandler(exitNum).isEnabled(); }
338  inline void disableExit(int exitNum) { getExitHandler(exitNum).disable(); }
339 
340 
341  InterpreterInstance *instance; // the interpreter we're running under
342  ActivityContext threadContext; // the handed out activity context
343  RexxActivity *oldActivity; // pushed nested activity
344  RexxActivationStack frameStack; /* our stack used for activation frames */
345  RexxDirectory *conditionobj; /* condition object for killed activi*/
346  RexxTable *requiresTable; /* Current ::REQUIRES being installed*/
347  RexxMessage *dispatchMessage; // a message object to run on this thread
348 
349 
350  // the activation frame stack. This stack is one RexxActivation or
351  // RexxNativeActivation for every level of the call stack. The activationStackSize
352  // is the current size of the stack (which is expanded, if necessary). The
353  // activationStackDepth is the current count of frames in the stack.
357 
358  // the following two fields represent the current top of the activation stack
359  // and the top Rexx frame in the stack. Generally, if executing Rexx code,
360  // then currentRexxFrame == topStackFrame. If we're at the base of the stack
361  // topStackFrame will be the root stack element (a RexxNativeActivation instance)
362  // and the currentRexxFrame will be OREF_NULL. If we've made a callout from a
363  // Rexx context, then the topStackFrame will be the RexxNativeActivation that
364  // made the callout and the currentRexxFrame will be the predecessor frame.
367  RexxString *currentExit; /* current executing system exit */
368  RexxObject *waitingObject; /* object activity is waiting on */
369  SysSemaphore runsem; /* activity run control semaphore */
370  SysSemaphore guardsem; /* guard expression semaphore */
371  SysActivity currentThread; /* descriptor for this thread */
372  NumericSettings *numericSettings; /* current activation setting values */
373 
374  bool stackcheck; /* stack space is to be checked */
375  bool exit; /* activity loop is to exit */
376  bool requestingString; /* in error handling currently */
377  bool suspended; // the suspension flag
378  bool interpreterRoot; // This is the root activity for an interpreter instance
379  bool attached; // this is attached to an instance (vs. created directly)
380  size_t nestedCount; /* extent of the nesting */
381  size_t attachCount; // extent of nested attaches
382  char *stackBase; /* pointer to base of C stack */
383  bool clauseExitUsed; /* halt/trace sys exit not set ==> 1 */
384  uint64_t randomSeed; /* random number seed */
385  ExitHandler sysexits[LAST_EXIT]; /* Array to hold system exits */
386  ProtectedObject *protectedObjects; // list of stack-based object protectors
387  ActivationFrame *activationFrames; // list of stack-based object protectors
388  RexxActivity *nestedActivity; // used to push down activities in threads with more than one instance
389 
390  // structures containing the various interface vectors
395  };
396 
397 
408 {
409  return contextToActivity(c)->getApiContext();
410 }
411 
412 
423 {
424  return ((CallContext *)c)->context;
425 }
426 
427 
438 {
439  return ((ExitContext *)c)->context;
440 }
441 
442 
453 {
454  return ((MethodContext *)c)->context;
455 }
456 
457 #endif
RexxActivity::traceInput
RexxString * traceInput(RexxActivation *)
Definition: RexxActivity.cpp:2861
RexxActivity::nestedActivity
RexxActivity * nestedActivity
Definition: RexxActivity.hpp:388
RexxActivity::callInitializationExit
void callInitializationExit(RexxActivation *)
Definition: RexxActivity.cpp:2054
RexxActivity::callExit
bool callExit(RexxActivation *activation, const char *exitName, int function, int subfunction, void *exitbuffer)
Definition: RexxActivity.cpp:2030
RexxActivity::queue
void queue(RexxActivation *, RexxString *, int)
Definition: RexxActivity.cpp:2968
CallbackDispatcher
Definition: CallbackDispatcher.hpp:47
RexxActivity::createNewActivationStack
void createNewActivationStack()
Definition: RexxActivity.cpp:1486
RexxActivity::runThread
void runThread()
Definition: RexxActivity.cpp:85
RexxExpressionStack
Definition: ExpressionStack.hpp:53
RexxActivity::setupExits
void setupExits()
Definition: RexxActivity.cpp:1685
RexxTable::stringGet
RexxObject * stringGet(RexxString *key)
Definition: TableClass.hpp:67
TRACE_PREFIX_FUNCTION
Definition: RexxActivity.hpp:87
TRACE_PREFIX_LITERAL
Definition: RexxActivity.hpp:86
RexxActivity::yieldControl
void yieldControl()
RexxActivity::clauseExitUsed
bool clauseExitUsed
Definition: RexxActivity.hpp:383
RexxArray
Definition: ArrayClass.hpp:100
SysSemaphore
Definition: SysSemaphore.hpp:52
RexxActivity::updateFrameMarkers
void updateFrameMarkers()
Definition: RexxActivity.cpp:1437
RexxActivity::guardsem
SysSemaphore guardsem
Definition: RexxActivity.hpp:370
RexxActivationStack::allocateFrame
RexxObject ** allocateFrame(size_t entries)
Definition: RexxActivationStack.hpp:115
RexxActivity::deactivate
void deactivate()
Definition: RexxActivity.hpp:256
SysSemaphore::reset
void reset()
Definition: SysSemaphore.cpp:213
RexxActivity::getApiContext
RexxNativeActivation * getApiContext()
Definition: RexxActivity.hpp:297
RexxActivity::requestingString
bool requestingString
Definition: RexxActivity.hpp:376
RexxActivity::isInterpreterRoot
bool isInterpreterRoot()
Definition: RexxActivity.hpp:263
RexxActivity::getLocal
RexxDirectory * getLocal()
Definition: RexxActivity.cpp:1980
NumericSettings
Definition: Numerics.hpp:49
ExpressionStack.hpp
RexxActivity::topStackFrame
RexxActivationBase * topStackFrame
Definition: RexxActivity.hpp:366
RexxInternalObject
Definition: ObjectClass.hpp:206
MethodContextInterface
Definition: oorexxapi.h:619
RexxActivity::callPullExit
bool callPullExit(RexxActivation *, RexxString *&)
Definition: RexxActivity.cpp:2495
CommandHandler
Definition: CommandHandler.hpp:52
RexxActivity::callQueueSizeExit
bool callQueueSizeExit(RexxActivation *, RexxInteger *&)
Definition: RexxActivity.cpp:2573
TRACE_PREFIX_ERROR
Definition: RexxActivity.hpp:81
RexxActivity::relinquish
void relinquish()
Definition: RexxActivity.cpp:1853
RexxThreadContext_
Definition: oorexxapi.h:710
RexxActivity::stackBase
char * stackBase
Definition: RexxActivity.hpp:382
RexxActivity::addRunningRequires
void addRunningRequires(RexxString *program)
Definition: RexxActivity.hpp:285
ActivityDispatcher
Definition: ActivityDispatcher.hpp:47
RexxActivity::threadContext
ActivityContext threadContext
Definition: RexxActivity.hpp:342
RexxActivity::getEffectiveSecurityManager
SecurityManager * getEffectiveSecurityManager()
Definition: RexxActivity.cpp:2782
RexxActivity::requiresTable
RexxTable * requiresTable
Definition: RexxActivity.hpp:346
ActivationFrame
Definition: ActivationFrame.hpp:49
RexxActivity::callObjectFunctionExit
bool callObjectFunctionExit(RexxActivation *, RexxString *, RexxObject *, ProtectedObject &, RexxObject **, size_t)
Definition: RexxActivity.cpp:2303
RexxActivity::enterKernel
void enterKernel()
Definition: RexxActivity.cpp:1757
RexxActivity::instance
InterpreterInstance * instance
Definition: RexxActivity.hpp:341
RexxActivity::createCallContext
void createCallContext(CallContext &context, RexxNativeActivation *owner)
Definition: RexxActivity.cpp:3153
RexxActivity::joinKernelQueue
void joinKernelQueue()
RexxActivity::enterCurrentThread
void enterCurrentThread()
Definition: RexxActivity.cpp:201
RexxActivity::checkActivationStack
void checkActivationStack()
Definition: RexxActivity.cpp:1414
RexxActivity::stackcheck
bool stackcheck
Definition: RexxActivity.hpp:374
RexxActivity::unwindToFrame
void unwindToFrame(RexxActivation *frame)
Definition: RexxActivity.cpp:1627
RexxActivity::allocateFrame
RexxObject ** allocateFrame(size_t entries)
Definition: RexxActivity.hpp:304
RexxActivity::exitCurrentThread
void exitCurrentThread()
Definition: RexxActivity.cpp:184
RexxActivity::returnAttach
void returnAttach()
Definition: RexxActivity.hpp:254
RexxActivity::isSuspended
bool isSuspended()
Definition: RexxActivity.hpp:261
RexxActivity::traceOutput
void traceOutput(RexxActivation *, RexxString *)
Definition: RexxActivity.cpp:2811
RexxTable::reset
void reset()
Definition: TableClass.cpp:156
RexxActivity::disableExit
void disableExit(int exitNum)
Definition: RexxActivity.hpp:338
CallContextInterface
Definition: oorexxapi.h:642
RexxThreadInterface
Definition: oorexxapi.h:455
FatalError
Definition: RexxActivity.hpp:111
RexxActivationStack
Definition: RexxActivationStack.hpp:101
RexxActivity::runningRequires
RexxObject * runningRequires(RexxString *program)
Definition: RexxActivity.hpp:284
RexxActivity::detachThread
void detachThread()
Definition: RexxActivity.cpp:1714
TRACE_PREFIX_PREFIX
Definition: RexxActivity.hpp:88
RexxActivity::halt
bool halt(RexxString *)
Definition: RexxActivity.cpp:1886
RexxActivity::callDebugInputExit
bool callDebugInputExit(RexxActivation *, RexxString *&)
Definition: RexxActivity.cpp:2153
ListClass.hpp
RexxActivity::buildMessage
RexxString * buildMessage(wholenumber_t, RexxArray *)
Definition: RexxActivity.cpp:1011
RexxActivity::run
void run()
Definition: RexxActivity.cpp:1384
RexxActivity::frameStack
RexxActivationStack frameStack
Definition: RexxActivity.hpp:344
RexxActivity::activations
RexxInternalStack * activations
Definition: RexxActivity.hpp:354
RexxActivity::postDispatch
void postDispatch()
Definition: RexxActivity.cpp:1834
RexxActivity::threadIdMethod
thread_id_t threadIdMethod()
Definition: RexxActivity.cpp:1988
TRACE_PREFIX_DOTVARIABLE
Definition: RexxActivity.hpp:85
RexxActivity::isThread
bool isThread(thread_id_t id)
Definition: RexxActivity.hpp:215
RexxActivity::createExitContext
void createExitContext(ExitContext &context, RexxNativeActivation *owner)
Definition: RexxActivity.cpp:3161
RexxActivity::guardWait
void guardWait()
Definition: RexxActivity.cpp:1807
RexxActivity::exitContextFunctions
static ExitContextInterface exitContextFunctions
Definition: RexxActivity.hpp:394
RexxActivity::allocateLocalVariableFrame
void allocateLocalVariableFrame(RexxLocalVariables *locals)
Definition: RexxActivity.hpp:314
RexxActivity::raisePropagate
void raisePropagate(RexxDirectory *)
Definition: RexxActivity.cpp:1148
TRACE_PREFIX_RESULT
Definition: RexxActivity.hpp:82
RexxActivity::requestAccess
void requestAccess()
Definition: RexxActivity.cpp:1945
TRACE_PREFIX_OPERATOR
Definition: RexxActivity.hpp:89
RexxActivity::checkStackSpace
void checkStackSpace()
Definition: RexxActivity.cpp:1964
RexxActivity::releaseAccess
void releaseAccess()
Definition: RexxActivity.cpp:1931
ExitHandler
Definition: ExitHandler.hpp:52
RexxHashTableCollection::remove
virtual RexxObject * remove(RexxObject *key)
Definition: RexxCollection.cpp:190
RexxActivity::guardPost
void guardPost()
Definition: RexxActivity.cpp:1817
RexxActivity::runsem
SysSemaphore runsem
Definition: RexxActivity.hpp:369
RexxActivity::reportAnException
void reportAnException(wholenumber_t, const char *)
Definition: RexxActivity.cpp:586
RecursiveStringError
Definition: RexxActivity.hpp:110
RexxActivity::attachCount
size_t attachCount
Definition: RexxActivity.hpp:381
RexxActivity::setTrace
bool setTrace(bool)
Definition: RexxActivity.cpp:1909
RexxLocalVariables.hpp
RexxActivity::flatten
void flatten(RexxEnvelope *)
Definition: RexxActivity.cpp:1369
RexxActivity::isNestedAttach
bool isNestedAttach()
Definition: RexxActivity.hpp:253
RexxActivationBase
Definition: ObjectClass.hpp:574
RexxActivity::setExitHandler
void setExitHandler(int exitNum, REXXPFN e)
Definition: RexxActivity.hpp:321
RexxActivity::reraiseException
void reraiseException(RexxDirectory *)
Definition: RexxActivity.cpp:1105
RexxActivity::oldActivity
RexxActivity * oldActivity
Definition: RexxActivity.hpp:343
RexxEnvelope
Definition: RexxEnvelope.hpp:53
RexxActivity::getLastMethod
RexxMethod * getLastMethod()
Definition: RexxActivity.cpp:3250
ExitHandler.hpp
RexxInternalStack
Definition: RexxInternalStack.hpp:48
TrappingDispatcher
Definition: TrappingDispatcher.hpp:47
RexxActivity::addToInstance
void addToInstance(InterpreterInstance *interpreter)
Definition: RexxActivity.cpp:1667
thread_id_t
pthread_t thread_id_t
Definition: rexxapitypes.h:65
RexxActivity::unwindStackFrame
void unwindStackFrame()
Definition: RexxActivity.cpp:1574
RexxActivity::setNestedActivity
void setNestedActivity(RexxActivity *a)
Definition: RexxActivity.hpp:265
RexxActivity::error
wholenumber_t error()
Definition: RexxActivity.cpp:323
RexxActivity::setupAttachedActivity
void setupAttachedActivity(InterpreterInstance *interpreter)
Definition: RexxActivity.cpp:1647
RexxActivity::pushStackFrame
void pushStackFrame(RexxActivationBase *new_activation)
Definition: RexxActivity.cpp:1462
RexxActivity::displayCondition
wholenumber_t displayCondition(RexxDirectory *conditionObject)
Definition: RexxActivity.cpp:376
RexxActivity::getTopStackFrame
RexxActivationBase * getTopStackFrame()
Definition: RexxActivity.hpp:281
RexxActivity::allocateStackFrame
void allocateStackFrame(RexxExpressionStack *stack, size_t entries)
Definition: RexxActivity.hpp:299
RexxActivity::getNumericSettings
NumericSettings * getNumericSettings()
Definition: RexxActivity.hpp:283
RexxActivity::createExceptionObject
RexxDirectory * createExceptionObject(wholenumber_t, RexxString *, RexxArray *, RexxObject *)
Definition: RexxActivity.cpp:813
_RXSYSEXIT::sysexit_code
int sysexit_code
Definition: rexx.h:192
RexxActivity::raiseException
void raiseException(wholenumber_t, RexxString *, RexxArray *, RexxObject *)
Definition: RexxActivity.cpp:740
RexxActivity::generateRandomNumberSeed
void generateRandomNumberSeed()
Definition: RexxActivity.cpp:298
RexxActivity::reset
void reset()
Definition: RexxActivity.cpp:278
RexxExpressionStack::setFrame
void setFrame(RexxObject **frames, size_t items)
Definition: ExpressionStack.hpp:71
RexxSource
Definition: SourceFile.hpp:131
RexxActivity::getCurrentRexxFrame
RexxActivation * getCurrentRexxFrame()
Definition: RexxActivity.hpp:280
RexxMethodContext_
Definition: oorexxapi.h:1404
CallContext
Definition: ActivationApiContexts.hpp:78
TRACE_PREFIX_VARIABLE
Definition: RexxActivity.hpp:84
RexxActivity::yield
void yield()
Definition: RexxActivity.cpp:1865
LAST_EXIT
#define LAST_EXIT
Definition: RexxActivity.hpp:116
RexxActivity::callSayExit
bool callSayExit(RexxActivation *, RexxString *)
Definition: RexxActivity.cpp:2084
RexxActivity::callValueExit
bool callValueExit(RexxActivation *, RexxString *, RexxString *, RexxObject *, RexxObject *&)
Definition: RexxActivity.cpp:2746
RexxActivity::previous
RexxObject * previous()
RexxActivity::getCurrentCondition
RexxDirectory * getCurrentCondition()
Definition: RexxActivity.hpp:319
RexxActivity::inheritSettings
void inheritSettings(RexxActivity *parent)
Definition: RexxActivity.cpp:3121
RexxActivity::callCommandExit
bool callCommandExit(RexxActivation *, RexxString *, RexxString *, ProtectedObject &result, ProtectedObject &condition)
Definition: RexxActivity.cpp:2435
RexxActivity::errorNumber
wholenumber_t errorNumber(RexxDirectory *conditionObject)
Definition: RexxActivity.cpp:408
RexxActivity::protectedObjects
ProtectedObject * protectedObjects
Definition: RexxActivity.hpp:386
RexxActivity::waitingObject
RexxObject * waitingObject
Definition: RexxActivity.hpp:368
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
RexxActivity::isActive
bool isActive()
Definition: RexxActivity.hpp:257
RexxActivity::activationStackSize
size_t activationStackSize
Definition: RexxActivity.hpp:355
RexxTable::stringAdd
RexxObject * stringAdd(RexxObject *, RexxString *)
Definition: TableClass.cpp:94
TRACE_PREFIX_DUMMY
Definition: RexxActivity.hpp:83
RexxActivity::releaseStackFrame
void releaseStackFrame(RexxObject **frame)
Definition: RexxActivity.hpp:309
RexxActivity::interpreterRoot
bool interpreterRoot
Definition: RexxActivity.hpp:378
RexxActivity::liveGeneral
void liveGeneral(int reason)
Definition: RexxActivity.cpp:1345
RexxActivity::unwindToDepth
void unwindToDepth(size_t depth)
Definition: RexxActivity.cpp:1604
RexxActivity
Definition: RexxActivity.hpp:127
TRACE_PREFIX_CLAUSE
Definition: RexxActivity.hpp:80
RexxActivity::waitForDispatch
void waitForDispatch()
Definition: RexxActivity.hpp:289
TRACE_PREFIX_INVOCATION
Definition: RexxActivity.hpp:94
contextToActivity
RexxActivity * contextToActivity(RexxThreadContext *c)
Definition: ActivationApiContexts.hpp:98
RexxDirectory
Definition: DirectoryClass.hpp:49
REXXPFN
void * REXXPFN
Definition: rexxapitypes.h:63
MethodContext
Definition: ActivationApiContexts.hpp:72
RexxActivity::currentRexxFrame
RexxActivation * currentRexxFrame
Definition: RexxActivity.hpp:365
RexxActivity::raiseCondition
bool raiseCondition(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *)
Definition: RexxActivity.cpp:434
RexxActivity::callTraceTestExit
bool callTraceTestExit(RexxActivation *, bool)
Definition: RexxActivity.cpp:2682
RexxActivity::callFunctionExit
bool callFunctionExit(RexxActivation *, RexxString *, RexxObject *, ProtectedObject &, RexxObject **, size_t)
Definition: RexxActivity.cpp:2187
SourceLocation.hpp
RexxActivity::lineOut
RexxObject * lineOut(RexxString *)
Definition: RexxActivity.cpp:2921
RexxActivity::generateProgramInformation
void generateProgramInformation(RexxDirectory *exObj)
Definition: RexxActivity.cpp:912
SysActivity.hpp
RexxActivity::checkDeadLock
void checkDeadLock(RexxActivity *)
Definition: RexxActivity.cpp:1768
RexxActivity::callPushExit
bool callPushExit(RexxActivation *, RexxString *, int)
Definition: RexxActivity.cpp:2536
ProtectedObject
Definition: ProtectedObject.hpp:46
RexxActivity::setInterpreterRoot
void setInterpreterRoot()
Definition: RexxActivity.hpp:264
RexxActivity::getRandomSeed
uint64_t getRandomSeed()
Definition: RexxActivity.hpp:291
RexxExitContext_
Definition: oorexxapi.h:2906
RexxActivity::resolveCommandHandler
CommandHandler * resolveCommandHandler(RexxString *)
Definition: RexxActivity.cpp:3215
_RXSYSEXIT
Definition: rexx.h:190
RexxActivity::getNestedActivity
RexxActivity * getNestedActivity()
Definition: RexxActivity.hpp:266
RexxActivity::guardSet
void guardSet()
Definition: RexxActivity.cpp:1825
RexxActivity::popStackFrame
void popStackFrame(bool reply)
Definition: RexxActivity.cpp:1508
RexxActivity::methodContextFunctions
static MethodContextInterface methodContextFunctions
Definition: RexxActivity.hpp:392
RexxActivity::callScriptingExit
bool callScriptingExit(RexxActivation *, RexxString *, RexxObject *, ProtectedObject &, RexxObject **, size_t)
Definition: RexxActivity.cpp:2374
RexxActivity::pullInput
RexxString * pullInput(RexxActivation *)
Definition: RexxActivity.cpp:2893
RexxLocalVariables::size
size_t size
Definition: RexxLocalVariables.hpp:141
UnhandledCondition
Definition: RexxActivity.hpp:112
RexxActivity::getActivationDepth
size_t getActivationDepth()
Definition: RexxActivity.hpp:282
RexxActivity::callTerminationExit
void callTerminationExit(RexxActivation *)
Definition: RexxActivity.cpp:2071
RexxActivationStack::releaseFrame
void releaseFrame(RexxObject **frame)
Definition: RexxActivationStack.hpp:122
RexxActivity::stackFrameDepth
size_t stackFrameDepth
Definition: RexxActivity.hpp:356
RexxActivity::resetRunningRequires
void resetRunningRequires()
Definition: RexxActivity.hpp:287
RexxMessage
Definition: MessageClass.hpp:54
RexxActivity::cleanupStackFrame
void cleanupStackFrame(RexxActivationBase *poppedStackFrame)
Definition: RexxActivity.cpp:1539
RexxInternalStack.hpp
ExitHandler::setEntryPoint
void setEntryPoint(REXXPFN e)
Definition: ExitHandler.hpp:56
TRACE_PREFIX_ARGUMENT
Definition: RexxActivity.hpp:92
RexxActivity::exitKernel
void exitKernel()
Definition: RexxActivity.cpp:1736
RexxActivity::validateThread
void validateThread()
Definition: RexxActivity.cpp:3224
RexxLocalVariables
Definition: RexxLocalVariables.hpp:61
RexxActivity::kill
void kill(RexxDirectory *)
Definition: RexxActivity.cpp:1843
RexxActivity::isInactive
bool isInactive()
Definition: RexxActivity.hpp:258
RexxActivity::clearWait
void clearWait()
Definition: RexxActivity.hpp:290
_RXSYSEXIT::sysexit_name
CSTRING sysexit_name
Definition: rexx.h:191
RexxActivity::displayDebug
RexxObject * displayDebug(RexxDirectory *)
Definition: RexxActivity.cpp:1283
TRACE_PREFIX_MESSAGE
Definition: RexxActivity.hpp:91
RexxActivity::getThreadContext
RexxThreadContext * getThreadContext()
Definition: RexxActivity.hpp:296
RexxActivity::checkRequires
bool checkRequires(RexxString *n)
Definition: RexxActivity.hpp:288
SecurityManager
Definition: SecurityManager.hpp:52
RexxActivity::messageSubstitution
RexxString * messageSubstitution(RexxString *, RexxArray *)
Definition: RexxActivity.cpp:1025
ActivationApiContexts.hpp
RexxActivity::setSuspended
void setSuspended(bool s)
Definition: RexxActivity.hpp:262
RexxActivity::attached
bool attached
Definition: RexxActivity.hpp:379
RexxActivity::callContextFunctions
static CallContextInterface callContextFunctions
Definition: RexxActivity.hpp:393
RexxActivity::generateStackFrames
RexxArray * generateStackFrames(bool skipFirst)
Definition: RexxActivity.cpp:976
RexxActivation
Definition: RexxActivation.hpp:156
RexxActivity::getInstanceSecurityManager
SecurityManager * getInstanceSecurityManager()
Definition: RexxActivity.cpp:2803
SysSemaphore::wait
void wait()
Definition: SysSemaphore.cpp:174
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
RexxTable
Definition: TableClass.hpp:49
RexxActivity::getLastMessageName
RexxString * getLastMessageName()
Definition: RexxActivity.cpp:3239
SysActivity
Definition: SysActivity.hpp:73
InterpreterInstance
Definition: InterpreterInstance.hpp:55
TRACE_PREFIX_COMPOUND
Definition: RexxActivity.hpp:90
RexxActivity::setExitHandler
void setExitHandler(RXSYSEXIT &e)
Definition: RexxActivity.hpp:323
RexxActivity::nestedCount
size_t nestedCount
Definition: RexxActivity.hpp:380
RexxActivationStack.hpp
RexxActivity::isExitEnabled
bool isExitEnabled(int exitNum)
Definition: RexxActivity.hpp:337
ExitContextInterface
Definition: oorexxapi.h:665
RexxActivity::setExitHandler
void setExitHandler(int exitNum, const char *e)
Definition: RexxActivity.hpp:322
RexxLocalVariables::setFrame
void setFrame(RexxObject **frame)
Definition: RexxLocalVariables.hpp:75
RexxActivity::callHaltClearExit
bool callHaltClearExit(RexxActivation *)
Definition: RexxActivity.cpp:2661
RexxActivity::clearCurrentCondition
void clearCurrentCondition()
Definition: RexxActivity.hpp:320
contextToActivation
RexxNativeActivation * contextToActivation(RexxThreadContext *c)
Definition: RexxActivity.hpp:407
RexxActivity::callQueueNameExit
bool callQueueNameExit(RexxActivation *, RexxString *&)
Definition: RexxActivity.cpp:2598
RexxActivity::restoreActivationLevel
void restoreActivationLevel(size_t l)
Definition: RexxActivity.hpp:260
RexxActivity::setRandomSeed
void setRandomSeed(uint64_t seed)
Definition: RexxActivity.hpp:292
TRACE_PREFIX_ASSIGNMENT
Definition: RexxActivity.hpp:93
RexxActivity::callHaltTestExit
bool callHaltTestExit(RexxActivation *)
Definition: RexxActivity.cpp:2631
ExitHandler::disable
void disable()
Definition: ExitHandler.hpp:62
RexxActivity::callTerminalInputExit
bool callTerminalInputExit(RexxActivation *, RexxString *&)
Definition: RexxActivity.cpp:2119
RexxNativeActivation
Definition: RexxNativeActivation.hpp:62
ActivityException
ActivityException
Definition: RexxActivity.hpp:108
ExitHandler::resolve
void resolve(const char *name)
Definition: ExitHandler.cpp:86
RexxActivity::sysexits
ExitHandler sysexits[(RXNOOFEXITS - 1)]
Definition: RexxActivity.hpp:385
RexxActivity::cleanupActivityResources
void cleanupActivityResources()
Definition: RexxActivity.cpp:172
SysActivity::equals
bool equals(thread_id_t t)
Definition: SysActivity.hpp:77
RexxActivity::RexxActivity
RexxActivity(RESTORETYPE restoreType)
Definition: RexxActivity.hpp:136
RexxActivity::callTraceExit
bool callTraceExit(RexxActivation *, RexxString *)
Definition: RexxActivity.cpp:2102
RexxActivity::getLocalEnvironment
RexxObject * getLocalEnvironment(RexxString *name)
Definition: RexxActivity.cpp:3200
RexxActivity::nestAttach
void nestAttach()
Definition: RexxActivity.hpp:252
RexxActivity::activationFrames
ActivationFrame * activationFrames
Definition: RexxActivity.hpp:387
RexxActivity::detachInstance
void detachInstance()
Definition: RexxActivity.cpp:1723
RexxActivity::waitReserve
void waitReserve(RexxObject *)
Definition: RexxActivity.cpp:1794
RexxActivity::numericSettings
NumericSettings * numericSettings
Definition: RexxActivity.hpp:372
RexxActivity::isClauseExitUsed
bool isClauseExitUsed()
Definition: RexxActivity.hpp:216
TracePrefixes
TracePrefixes
Definition: RexxActivity.hpp:79
ExitContext
Definition: ActivationApiContexts.hpp:84
ExitHandler::isEnabled
bool isEnabled()
Definition: ExitHandler.hpp:57
RexxActivity::initializeThreadContext
static void initializeThreadContext()
Definition: RexxActivity.cpp:1702
RexxActivity::display
RexxObject * display(RexxDirectory *)
Definition: RexxActivity.cpp:1182
RexxActivity::getExitHandler
ExitHandler & getExitHandler(int exitNum)
Definition: RexxActivity.hpp:336
RexxCallContext_
Definition: oorexxapi.h:2154
RexxActivity::spawnReply
RexxActivity * spawnReply()
Definition: RexxActivity.cpp:292
RexxActivity::removeRunningRequires
void removeRunningRequires(RexxObject *program)
Definition: RexxActivity.hpp:286
RexxActivity::currentExit
RexxString * currentExit
Definition: RexxActivity.hpp:367
RESTORETYPE
RESTORETYPE
Definition: ObjectClass.hpp:80
RexxActivity::exit
bool exit
Definition: RexxActivity.hpp:375
RexxActivity::activate
void activate()
Definition: RexxActivity.hpp:255
RexxActivity::terminatePoolActivity
void terminatePoolActivity()
Definition: RexxActivity.cpp:2999
RexxActivity::conditionobj
RexxDirectory * conditionobj
Definition: RexxActivity.hpp:345
RexxActivity::randomSeed
uint64_t randomSeed
Definition: RexxActivity.hpp:384
ActivityContext::threadContext
RexxThreadContext threadContext
Definition: ActivationApiContexts.hpp:67
RexxActivity::live
void live(size_t)
Definition: RexxActivity.cpp:1321
RexxMethod
Definition: MethodClass.hpp:101
RexxActivity::createMethodContext
void createMethodContext(MethodContext &context, RexxNativeActivation *owner)
Definition: RexxActivity.cpp:3138
RexxInteger
Definition: IntegerClass.hpp:56
RexxActivity::suspended
bool suspended
Definition: RexxActivity.hpp:377
RexxActivity::createConditionObject
RexxDirectory * createConditionObject(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *)
Definition: RexxActivity.cpp:488
ActivityContext
Definition: ActivationApiContexts.hpp:65
RexxActivity::RexxActivity
RexxActivity()
RexxActivity::lineIn
RexxString * lineIn(RexxActivation *)
Definition: RexxActivity.cpp:2936
RexxActivity::callNovalueExit
bool callNovalueExit(RexxActivation *, RexxString *, RexxObject *&)
Definition: RexxActivity.cpp:2720
RexxActivity::queryTrcHlt
void queryTrcHlt()
Definition: RexxActivity.cpp:1996
RexxActivity::dispatchMessage
RexxMessage * dispatchMessage
Definition: RexxActivity.hpp:347
RexxObject
Definition: ObjectClass.hpp:311
RexxActivity::getActivationLevel
size_t getActivationLevel()
Definition: RexxActivity.hpp:259
RexxActivity::resolveProgramName
RexxString * resolveProgramName(RexxString *, RexxString *, RexxString *)
Definition: RexxActivity.cpp:3187
RexxActivity::currentThread
SysActivity currentThread
Definition: RexxActivity.hpp:371
RexxActivity::threadContextFunctions
static RexxThreadInterface threadContextFunctions
Definition: RexxActivity.hpp:391
RexxString
Definition: StringClass.hpp:119
RexxActivity::sayOutput
void sayOutput(RexxActivation *, RexxString *)
Definition: RexxActivity.cpp:2837
RexxActivity::getInstance
InterpreterInstance * getInstance()
Definition: RexxActivity.hpp:250
RexxActivity::isAttached
bool isAttached()
Definition: RexxActivity.hpp:267