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.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 RexxActivation.hpp */
40 /* */
41 /* Primitive Activation Class Definitions */
42 /* */
43 /******************************************************************************/
44 #ifndef Included_RexxActivation
45 #define Included_RexxActivation
46 
47 #include "ExpressionStack.hpp" /* needs expression stack */
48 #include "DoBlock.hpp" /* need do block definition */
49  /* various activation settings */
50 #include "RexxLocalVariables.hpp" /* local variable cache definitions */
51 #include "RexxDateTime.hpp"
52 #include "RexxCode.hpp"
53 #include "ActivityManager.hpp"
54 #include "RexxCompoundTail.hpp"
55 #include "ContextClass.hpp"
56 
57 
59 class ProtectedObject;
60 class RexxSupplier;
61 class PackageClass;
62 class StackFrameClass;
63 
64 
65 /******************************************************************************/
66 /* Random number generation constants */
67 /******************************************************************************/
68 
69 const uint64_t RANDOM_FACTOR = 25214903917LL; /* random multiplication factor */
70 const uint64_t RANDOM_ADDER = 11LL;
71  /* randomize a seed number */
72 inline uint64_t RANDOMIZE(uint64_t seed) { return (seed * RANDOM_FACTOR + RANDOM_ADDER); }
73  // size of a size_t value in bits
74 const size_t SIZE_BITS = sizeof(void *) * 8;
75 
76 /* execution_state values */
77 #define ACTIVE 0
78 #define REPLIED 1
79 #define RETURNED 2
80 
81 #define RETURN_STATUS_NORMAL 0
82 #define RETURN_STATUS_ERROR 1
83 #define RETURN_STATUS_FAILURE -1
84 
85 
86 #define MS_PREORDER 0x01 /* Macro Space Pre-Search */
87 #define MS_POSTORDER 0x02 /* Macro Space Post-Search */
88 
89 
90 
91  /* NOTE: a template structure for */
92  /* the following is created in */
93  /* OKACTIVA.C to allow quick */
94  /* initialization of new activations.*/
95  /* That template MUST be updated */
96  /* whenever the settings structure */
97  /* changes */
98 
100 {
101  public:
102  inline ActivationSettings() {}
103 
104  RexxDirectory * traps; /* enabled condition traps */
105  RexxDirectory * conditionObj; /* current condition object */
106  RexxObject ** parent_arglist; /* arguments to top level program */
107  size_t parent_argcount; /* number of arguments to the top level program */
108  RexxMethod * parent_method; /* method object for top level */
109  RexxCode * parent_code; /* source of the parent method */
110  RexxString * current_env; /* current address environment */
111  RexxString * alternate_env; /* alternate address environment */
112  RexxString * msgname; /* message sent to the receiver */
113  /* object variable dictionary */
115  RexxString * calltype; /* (COMMAND/METHOD/FUNCTION/ROUTINE) */
116  RexxDirectory * streams; /* Directory of openned streams */
117  RexxString * halt_description; /* description from a HALT condition */
118  SecurityManager * securityManager; /* security manager object */
119  RexxObject * scope; // scope of the method call
120  size_t traceOption; /* current active trace option */
121  size_t flags; /* trace/numeric and other settings */
122  wholenumber_t trace_skip; /* count of trace events to skip */
123  int return_status; /* command return status */
124  size_t traceindent; /* trace indentation */
125  NumericSettings numericSettings; /* globally effective settings */
126  int64_t elapsed_time; /* elapsed time clock */
127  RexxDateTime timestamp; /* current timestamp */
128  bool intermediate_trace; /* very quick test for intermediate trace */
129  RexxLocalVariables local_variables; /* the local variables for this activation */
130 };
131 
132  /* activation_context values */
133  /* these are done as bit settings to */
134  /* allow multiple potential values */
135  /* to be checked with a single test */
136 #define DEBUGPAUSE 0x00000001
137 #define METHODCALL 0x00000002
138 #define INTERNALCALL 0x00000004
139 #define INTERPRET 0x00000008
140 #define PROGRAMCALL 0x00000010
141 #define EXTERNALCALL 0x00000020
142 
143  /* check for top level execution */
144 #define TOP_LEVEL_CALL (PROGRAMCALL | METHODCALL | EXTERNALCALL)
145  /* non-method top level execution */
146 #define PROGRAM_LEVEL_CALL (PROGRAMCALL | EXTERNALCALL)
147  /* non-method top level execution */
148 #define PROGRAM_OR_METHOD (PROGRAMCALL | METHODCALL)
149  /* call is within an activation */
150 #define INTERNAL_LEVEL_CALL (INTERNALCALL | INTERPRET)
151 
152 /* object_scope values */
153 #define SCOPE_RESERVED 1
154 #define SCOPE_RELEASED 0
155 
157  friend class RexxSource;
158  public:
159  void *operator new(size_t);
160  inline void *operator new(size_t size, void *ptr) {return ptr;};
161  inline void operator delete(void *) { ; }
162  inline void operator delete(void *, void *) { ; }
163 
164  inline RexxActivation(RESTORETYPE restoreType) { ; };
165  RexxActivation();
166  RexxActivation(RexxActivity* _activity, RexxMethod *_method, RexxCode *_code);
167  RexxActivation(RexxActivity *_activity, RoutineClass *_routine, RexxCode *_code, RexxString *calltype, RexxString *env, int context);
168  RexxActivation(RexxActivity *_activity, RexxActivation *_parent, RexxCode *_code, int context);
169 
170  void live(size_t);
171  void liveGeneral(int reason);
172  RexxObject * dispatch();
173  size_t digits();
174  size_t fuzz();
175  bool form();
176  void setDigits(size_t);
177  void setFuzz(size_t);
178  void setForm(bool);
179  void setDigits();
180  void setFuzz();
181  void setForm();
182  bool trap(RexxString *, RexxDirectory *);
183  void setObjNotify(RexxMessage *);
184  void termination();
185  inline void guardOff()
186  {
187  /* currently locked? */
188  if (this->object_scope == SCOPE_RESERVED) {
189  /* release the variable dictionary */
191  /* set the state to released */
193  }
194  }
195 
196 
197  inline bool isInterpret() { return activation_context == INTERPRET; }
198  inline bool isInternalCall() { return activation_context == INTERNALCALL; }
199  inline bool isMethod() { return activation_context == METHODCALL; }
200  inline bool isRoutine() { return activation_context == EXTERNALCALL; }
201  inline bool isProgram() { return activation_context == PROGRAMCALL; }
202  inline bool isTopLevelCall() { return (activation_context & TOP_LEVEL_CALL) != 0; }
203  inline bool isProgramLevelCall() { return (activation_context & PROGRAM_LEVEL_CALL) != 0; }
204  inline bool isInternalLevelCall() { return (activation_context & INTERNAL_LEVEL_CALL) != 0; }
205  inline bool isProgramOrMethod() { return (activation_context & PROGRAM_OR_METHOD) != 0; }
206  inline bool isMethodOrRoutine() { return isMethod() || isRoutine(); }
207 
208  RexxObject *run(RexxObject *_receiver, RexxString *msgname, RexxObject **_arglist,
209  size_t _argcount, RexxInstruction * start, ProtectedObject &resultObj);
210  inline RexxObject *run(RexxObject **_arglist, size_t _argcount, ProtectedObject &_result)
211  {
212  return run(OREF_NULL, OREF_NULL, _arglist, _argcount, OREF_NULL, _result);
213  }
214  void reply(RexxObject *);
215  RexxObject * forward(RexxObject *, RexxString *, RexxObject *, RexxObject **, size_t, bool);
217  void exitFrom(RexxObject *);
218  void procedureExpose(RexxVariableBase **variables, size_t count);
219  void expose(RexxVariableBase **variables, size_t count);
220  void setTrace(size_t, size_t);
221  void setTrace(RexxString *);
222  static size_t processTraceSetting(size_t traceSetting);
223  void raise(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *, RexxDirectory *);
224  void toggleAddress();
225  void guardOn();
229  void interpret(RexxString *);
230  void signalTo(RexxInstruction *);
231  void guardWait();
232  void debugSkip(wholenumber_t, bool);
234  void iterate(RexxString *);
235  void leaveLoop(RexxString *);
237  void trapOff(RexxString *);
238  void setAddress(RexxString *);
239  void signalValue(RexxString *);
241  void trapDelay(RexxString *);
242  void trapUndelay(RexxString *);
248  static RoutineClass* getMacroCode(RexxString *macroName);
252  void command(RexxString *, RexxString *);
253  int64_t getElapsed();
256  size_t currentLine();
257  void arguments(RexxObject *);
258  void traceValue(RexxObject *, int);
259  void traceCompoundValue(int prefix, RexxString *stemName, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail);
260  void traceCompoundValue(int prefix, RexxString *stem, RexxObject **tails, size_t tailCount, const char *marker, RexxObject * value);
261  void traceTaggedValue(int prefix, const char *tagPrefix, bool quoteTag, RexxString *tag, const char *marker, RexxObject * value);
262  void traceOperatorValue(int prefix, const char *tag, RexxObject *value);
263  void traceSourceString();
264  void traceClause(RexxInstruction *, int);
265  void traceEntry();
266  void resetElapsed();
269  RexxDirectory * local();
271  RexxArray * getStackFrames(bool skipFirst);
272  inline void implicitExit()
273  {
274  /* at a main program level or completing an INTERPRET */
275  /* instruction? */
277  /* real program call? */
279  {
280  /* run termination exit */
281  this->activity->callTerminationExit(this);
282  }
283  this->execution_state = RETURNED;/* this is an EXIT for real */
284  return; /* we're finished here */
285  }
286  this->exitFrom(OREF_NULL); /* we've had a nested exit, we need to process this more fully */
287  }
288 
289  void unwindTrap(RexxActivation *);
291  void addLocalRoutine(RexxString *name, RexxMethod *method);
293  void debugInterpret(RexxString *);
294  bool debugPause(RexxInstruction * instr=OREF_NULL);
295  void processClauseBoundary();
296  bool halt(RexxString *);
297  void externalTraceOn();
298  void externalTraceOff();
299  void yield();
300  void propagateExit(RexxObject *);
302  bool internalMethod();
306  void pushEnvironment(RexxObject *);
308  void processTraps();
309  void mergeTraps(RexxQueue *, RexxQueue *);
310  uint64_t getRandomSeed(RexxInteger *);
311  void adjustRandomSeed() { random_seed += (uint64_t)(uintptr_t)this; }
316  void pushControl(RexxObject *);
317  void closeStreams();
318  void checkTrapTable();
319  RexxObject *resolveStream(RexxString *name, bool input, RexxString **fullName, bool *added);
324  RexxObject *handleNovalueEvent(RexxString *name, RexxObject *defaultValue, RexxVariable *variable);
328  }
331  void setReturnStatus(int status);
332 
333  inline void setCallType(RexxString *type) {this->settings.calltype = type; }
334  inline void pushBlock(RexxDoBlock *block) { block->setPrevious(this->dostack); this->dostack = block; }
335  inline void popBlock() { RexxDoBlock *temp; temp = this->dostack; this->dostack = temp->getPrevious(); temp->setHasNoReferences(); }
336  inline RexxDoBlock * topBlock() { return this->dostack; }
337  inline void terminateBlock(size_t _indent) { this->popBlock(); this->blockNest--; this->settings.traceindent = _indent; }
338  inline void terminateBlock() { this->settings.traceindent = this->dostack->getIndent(); this->popBlock(); this->blockNest--; }
339  inline void newDo(RexxDoBlock *block) { this->pushBlock(block); this->blockNest++; this->settings.traceindent++;}
340  inline void removeBlock() { this->blockNest--; unindent(); };
341  inline void addBlock() { this->blockNest++; indent(); };
342  inline bool hasActiveBlocks() { return blockNest != 0; }
343  inline bool inMethod() {return this->activation_context == METHODCALL; }
344  inline void indent() {this->settings.traceindent++; };
345  inline void unindent() {if (this->settings.traceindent > 0) this->settings.traceindent--; };
346  inline void setIndent(size_t v) {this->settings.traceindent=(v); };
347  inline size_t getIndent() {return this->settings.traceindent;};
348  inline bool tracingIntermediates() {return this->settings.intermediate_trace;};
350  inline bool tracingResults() {return (this->settings.flags&trace_results) != 0; }
351  inline RexxActivity * getActivity() {return this->activity;};
352  inline RexxString * getMessageName() {return this->settings.msgname;};
353  inline RexxString * getCallname() {return this->settings.msgname;};
354  inline RexxInstruction * getCurrent() {return this->current;};
355  inline void getSettings(ActivationSettings &s) {this->settings = s;};
356  inline void putSettings(ActivationSettings &s) {s = this->settings;};
357  inline RexxString * getAddress() {return this->settings.current_env;};
360  inline RexxInstruction * getNext() {return this->next;};
361  inline void setNext(RexxInstruction * v) {this->next=v;};
362  inline void setCurrent(RexxInstruction * v) {this->current=v;};
363  inline bool inDebug() { return ((this->settings.flags&trace_debug) != 0) && !this->debug_pause;}
364 
365  inline RexxExpressionStack * getStack() {return &this->stack; };
366 
368  virtual RexxActivation *getRexxContext();
369  virtual RexxActivation *findRexxContext();
370  virtual RexxObject *getReceiver();
371  virtual bool isRexxContext();
372 
373  inline void traceIntermediate(RexxObject * v, int p) { if (this->settings.intermediate_trace) this->traceValue(v, p); };
374  inline void traceVariable(RexxString *n, RexxObject *v)
375  { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_VARIABLE, NULL, false, n, VALUE_MARKER, v); } };
377  { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_DOTVARIABLE, ".", false, n, VALUE_MARKER, v); } };
378  inline void traceFunction(RexxString *n, RexxObject *v)
379  { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_FUNCTION, NULL, false, n, VALUE_MARKER, v); } };
380  inline void traceMessage(RexxString *n, RexxObject *v)
381  { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_MESSAGE, NULL, true, n, VALUE_MARKER, v); } };
382  inline void traceOperator(const char *n, RexxObject *v)
383  { if (this->settings.intermediate_trace) { this->traceOperatorValue(TRACE_PREFIX_OPERATOR, n, v); } };
384  inline void tracePrefix(const char *n, RexxObject *v)
385  { if (this->settings.intermediate_trace) { this->traceOperatorValue(TRACE_PREFIX_PREFIX, n, v); } };
387  { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_ASSIGNMENT, NULL, false, n, ASSIGNMENT_MARKER, v); } };
388  inline void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_COMPOUND, stemVar, tails, tailCount, VALUE_MARKER, tail->createCompoundName(stemVar)); };
389  inline void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxString *tail) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_COMPOUND, stemVar, tails, tailCount, VALUE_MARKER, stemVar->concat(tail)); };
390  inline void traceCompound(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_VARIABLE, stemVar, tails, tailCount, VALUE_MARKER, value); };
391  inline void traceCompoundAssignment(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_ASSIGNMENT, stemVar, tails, tailCount, ASSIGNMENT_MARKER, value); };
392  inline void traceResult(RexxObject * v) { if ((this->settings.flags&trace_results)) this->traceValue(v, TRACE_PREFIX_RESULT); };
393  inline bool tracingInstructions(void) { return (this->settings.flags&trace_all) != 0; }
394  inline bool tracingErrors(void) { return (this->settings.flags&trace_errors) != 0; }
395  inline bool tracingFailures(void) { return (this->settings.flags&trace_failures) != 0; }
397  inline void traceLabel(RexxInstruction * v) { if ((this->settings.flags&trace_labels) != 0) this->traceClause(v, TRACE_PREFIX_CLAUSE); };
398  inline void traceCommand(RexxInstruction * v) { if ((this->settings.flags&trace_commands) != 0) this->traceClause(v, TRACE_PREFIX_CLAUSE); }
399  inline bool tracingCommands(void) { return (this->settings.flags&trace_commands) != 0; }
400  inline bool tracingAll(void) { return (this->settings.flags&trace_all) != 0; }
401  inline void pauseInstruction() { if ((this->settings.flags&(trace_all | trace_debug)) == (trace_all | trace_debug)) this->debugPause(); };
402  inline int conditionalPauseInstruction() { return (((this->settings.flags&(trace_all | trace_debug)) == (trace_all | trace_debug)) ? this->debugPause(): false); };
403  inline void pauseLabel() { if ((this->settings.flags&(trace_labels | trace_debug)) == (trace_labels | trace_debug)) this->debugPause(); };
404  inline void pauseCommand() { if ((this->settings.flags&(trace_commands | trace_debug)) == (trace_commands | trace_debug)) this->debugPause(); };
405 
408  inline bool isTopLevel() { return (this->activation_context&TOP_LEVEL_CALL) != 0; }
409  inline bool isForwarded() { return (this->settings.flags&forwarded) != 0; }
410  inline bool isGuarded() { return (this->settings.flags&guarded_method) != 0; }
411  inline void setGuarded() { this->settings.flags |= guarded_method; }
412 
413  inline bool isExternalTraceOn() { return (this->settings.flags&trace_on) != 0; }
414  inline void setExternalTraceOn() { this->settings.flags |= trace_on; }
415  inline void setExternalTraceOff() { this->settings.flags &= ~trace_on; }
416  void enableExternalTrace();
417 
418  inline bool isElapsedTimerReset() { return (this->settings.flags&elapsed_reset) != 0; }
420  inline void setElapsedTimerValid() { this->settings.flags &= ~elapsed_reset; }
421 
422 
423  inline RexxObject ** getMethodArgumentList() {return this->arglist;};
424  inline size_t getMethodArgumentCount() { return argcount; }
425  inline RexxObject * getMethodArgument(size_t position) {
427  return OREF_NULL;
428  }
429  else {
430  return arglist[position-1];
431  }
432  }
433 
435 
438 
439  inline RexxObject * getProgramArgument(size_t position) {
441  return OREF_NULL;
442  }
443  else {
444  return settings.parent_arglist[position-1];
445  }
446  }
447 
450  size_t getContextLineNumber();
453 
455  {
457  }
458 
460  {
462  }
463 
464  inline RexxVariable *getLocalVariable(RexxString *name, size_t index)
465  {
466  RexxVariable *target = settings.local_variables.get(index);
467  if (target == OREF_NULL) {
468  target = settings.local_variables.lookupVariable(name, index);
469  }
470  return target;
471  }
472 
473  inline RexxVariable *getLocalStemVariable(RexxString *name, size_t index)
474  {
475  RexxVariable *target = settings.local_variables.get(index);
476  if (target == OREF_NULL) {
477  target = settings.local_variables.lookupStemVariable(name, index);
478  }
479  return target;
480  }
481 
482  inline RexxStem *getLocalStem(RexxString *name, size_t index)
483  {
484  return (RexxStem *)getLocalStemVariable(name, index)->getVariableValue();
485  }
486 
487  inline void dropLocalStem(RexxString *name, size_t index)
488  {
489  RexxVariable *stemVar = getLocalStemVariable(name, index);
490  /* create a new stem element and set this */
491  stemVar->set(new RexxStem(name));
492  }
493 
494  inline bool localStemVariableExists(RexxString *stemName, size_t index)
495  {
496  /* get the stem entry from this dictionary */
497  RexxVariable *variable = settings.local_variables.find(stemName, index);
498  /* The stem exists if the stem variable has ever been used. */
499  return variable != OREF_NULL;
500  }
501 
502  inline bool localVariableExists(RexxString *name, size_t index)
503  {
504  /* get the stem entry from this dictionary */
505  RexxVariable *variable = settings.local_variables.find(name, index);
506  /* The stem exists if the stem variable has ever been used. */
507  return variable != OREF_NULL && variable->getVariableValue() != OREF_NULL;
508  }
509 
510  inline void putLocalVariable(RexxVariable *variable, size_t index)
511  {
512  settings.local_variables.putVariable(variable, index);
513  }
514 
515  inline void updateLocalVariable(RexxVariable *variable)
516  {
518  }
519 
520  inline void setLocalVariable(RexxString *name, size_t index, RexxObject *value)
521  {
522  RexxVariable *variable = getLocalVariable(name, index);
523  variable->set(value);
524  }
525 
526  inline void dropLocalVariable(RexxString *name, size_t index)
527  {
528  RexxVariable *variable = getLocalVariable(name, index);
529  variable->drop();
530  }
531 
532  RexxObject *evaluateLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount);
533  RexxObject *getLocalCompoundVariableValue(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount);
534  RexxObject *getLocalCompoundVariableRealValue(RexxString *localstem, size_t index, RexxObject **tail, size_t tailCount);
535  RexxCompoundElement *getLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount);
536  RexxCompoundElement *exposeLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount);
537  bool localCompoundVariableExists(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount);
538  void assignLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount, RexxObject *value);
539  void setLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount, RexxObject *value);
540  void dropLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount);
541 
542  inline bool novalueEnabled() { return settings.local_variables.getNovalue(); }
543 
544  /* The following methods be rights should be implemented by the */
545  /* RexxMemory class, but aren't because of the difficulties of */
546  /* making them inline methods that use the RexxVariable class. */
547  /* Therefore, we're going to break the encapsulation rules */
548  /* slightly and allow the activation class to manipulate that */
549  /* chain directly. */
551  {
552  RexxVariable *newVariable = memoryObject.variableCache;
553  if (newVariable != OREF_NULL) {
554  memoryObject.variableCache = newVariable->getNext();
555  newVariable->reset(name);
556  }
557  else {
558  newVariable = new_variable(name);
559  }
560  newVariable->setCreator(this);
561  return newVariable;
562  }
563 
565  {
568  }
569 
570  inline void cleanupLocalVariables()
571  {
572  /* if we're nested, we need to make sure that any variable */
573  /* dictionary created at this level is propagated back to */
574  /* the caller. */
576  {
578  }
579  else
580  {
581  // we need to cleanup the local variables and return them to the
582  // cache.
583  for (size_t i = 0; i < settings.local_variables.size; i++)
584  {
586  if (var != OREF_NULL && var->isLocal(this))
587  {
588  cacheLocalVariable(var);
589  }
590  }
591  }
592  }
593 
595 
596  protected:
597 
598  ActivationSettings settings; /* inherited REXX settings */
599  RexxExpressionStack stack; /* current evaluation stack */
600  RexxCode *code; /* rexx method object */
601  RexxSource *sourceObject; // the source object associated with this instance
602  RexxClass *scope; // scope of any active method call
603  RexxObject *receiver; /* target of a message invocation */
604  RexxActivity *activity; /* current running activation */
605  RexxActivation *parent; // previous running activation for internal call/interpret
606  RexxObject **arglist; /* activity argument list */
607  size_t argcount; /* the count of arguments */
608  RexxDoBlock *dostack; /* stack of DO loops */
609  RexxInstruction *current; /* current execution pointer */
610  RexxInstruction *next; /* next instruction to execute */
611  bool debug_pause; /* executing a debug pause */
612  int object_scope; /* reserve/release state of variables*/
613  RexxObject *result; /* result of execution */
614  RexxArray *trapinfo; /* current trap handler */
615  RexxContext *contextObject; // the context object representing the execution context
616  /* current activation state */
618  /* type of activation activity */
620  RexxMessage *objnotify; /* an object to notify if excep occur*/
621  /* LIst of Saved Local environments */
623  size_t pending_count; /* number of pending conditions */
624  RexxQueue *handler_queue; /* queue of trapped condition handler*/
625  /* queue of trapped conditions */
627  uint64_t random_seed; /* random number seed */
628  bool random_set; /* random seed has been set */
629  size_t blockNest; /* block instruction nesting level */
630  size_t lookaside_size;/* size of the lookaside table */
631 
632 
633  // constants
634 
635  static const size_t trace_off; /* no tracing */
636  static const size_t trace_debug; /* interactive trace mode flag */
637  static const size_t trace_all; /* trace all instructions */
638  static const size_t trace_results; /* trace all results */
639  static const size_t trace_intermediates; /* trace all instructions */
640  static const size_t trace_commands; /* trace all commands */
641  static const size_t trace_labels; /* trace all labels */
642  static const size_t trace_errors; /* trace all command errors */
643  static const size_t trace_failures; /* trace all command failures */
644  static const size_t trace_suppress; /* tracing is suppressed during skips*/
645  static const size_t trace_flags; /* all tracing flags (EXCEPT debug) */
646  static const size_t default_trace_flags;
647  static const size_t trace_all_flags; // flag set for trace all
648  static const size_t trace_results_flags; // flag set for trace results
649  static const size_t trace_intermediates_flags; // flag set for trace intermediates
650 
651  static const size_t single_step; /* we are single stepping execution */
652  static const size_t single_step_nested; /* this is a nested stepping */
653  static const size_t debug_prompt_issued; /* debug prompt already issued */
654  static const size_t debug_bypass; /* skip next debug pause */
655  static const size_t procedure_valid; /* procedure instruction is valid */
656  static const size_t clause_boundary; /* work required at clause boundary */
657  static const size_t halt_condition; /* a HALT condition occurred */
658  static const size_t trace_on; /* external trace condition occurred */
659  static const size_t source_traced; /* source string has been traced */
660  static const size_t clause_exits; /* need to call clause boundary exits*/
661  static const size_t external_yield; /* activity wants us to yield */
662  static const size_t forwarded; /* forward instruction active */
663  static const size_t reply_issued; /* reply has already been issued */
664  static const size_t set_trace_on; /* trace turned on externally */
665  static const size_t set_trace_off; /* trace turned off externally */
666  static const size_t traps_copied; /* copy of trap info has been made */
667  static const size_t return_status_set; /* had our first host command */
668  static const size_t transfer_failed; /* transfer of variable lock failure */
669 
670  static const size_t elapsed_reset; // The elapsed time stamp was reset via time('r')
671  static const size_t guarded_method; // this is a guarded method
672  };
673  #endif
RexxMemory::variableCache
RexxVariable * variableCache
Definition: RexxMemory.hpp:294
RexxActivation::getRexxContext
virtual RexxActivation * getRexxContext()
Definition: RexxActivation.cpp:1996
RexxActivation::setExternalTraceOff
void setExternalTraceOff()
Definition: RexxActivation.hpp:415
RexxActivation::callExternalRexx
bool callExternalRexx(RexxString *, RexxObject **, size_t, RexxString *, ProtectedObject &)
Definition: RexxActivation.cpp:2668
RexxActivation::trace_results
static const size_t trace_results
Definition: RexxActivation.hpp:638
RexxActivation::internalCall
RexxObject * internalCall(RexxString *, RexxInstruction *, size_t, RexxExpressionStack *, ProtectedObject &)
Definition: RexxActivation.cpp:2844
RexxActivation::trace_failures
static const size_t trace_failures
Definition: RexxActivation.hpp:643
RexxActivation::newDo
void newDo(RexxDoBlock *block)
Definition: RexxActivation.hpp:339
ActivationSettings::numericSettings
NumericSettings numericSettings
Definition: RexxActivation.hpp:125
RexxActivation::traceAssignment
void traceAssignment(RexxString *n, RexxObject *v)
Definition: RexxActivation.hpp:386
RexxActivation::getIndent
size_t getIndent()
Definition: RexxActivation.hpp:347
RexxActivation::contextObject
RexxContext * contextObject
Definition: RexxActivation.hpp:615
RexxActivation::tracingInstructions
bool tracingInstructions(void)
Definition: RexxActivation.hpp:393
RexxActivation::traceSetting
RexxString * traceSetting()
Definition: RexxActivation.cpp:734
RexxLocalVariables::getNovalue
bool getNovalue()
Definition: RexxLocalVariables.hpp:131
RexxActivation::getArguments
RexxArray * getArguments()
Definition: RexxActivation.hpp:434
RexxActivation::setReturnStatus
void setReturnStatus(int status)
Definition: RexxActivation.cpp:3960
RexxActivation::trapState
RexxString * trapState(RexxString *)
Definition: RexxActivation.cpp:2052
RexxDoBlock::setPrevious
void setPrevious(RexxDoBlock *block)
Definition: DoBlock.hpp:74
RexxActivation::handler_queue
RexxQueue * handler_queue
Definition: RexxActivation.hpp:624
new_array
RexxArray * new_array(size_t s)
Definition: ArrayClass.hpp:250
RexxExpressionStack
Definition: ExpressionStack.hpp:53
RexxActivation::forward
RexxObject * forward(RexxObject *, RexxString *, RexxObject *, RexxObject **, size_t, bool)
Definition: RexxActivation.cpp:1246
RexxActivation::isInternalLevelCall
bool isInternalLevelCall()
Definition: RexxActivation.hpp:204
TRACE_PREFIX_FUNCTION
Definition: RexxActivity.hpp:87
RexxActivation::isExternalTraceOn
bool isExternalTraceOn()
Definition: RexxActivation.hpp:413
RexxArray
Definition: ArrayClass.hpp:100
ActivationSettings::local_variables
RexxLocalVariables local_variables
Definition: RexxActivation.hpp:129
RexxActivation::externalCall
RexxObject * externalCall(RexxString *, size_t, RexxExpressionStack *, RexxString *, ProtectedObject &)
Definition: RexxActivation.cpp:2597
RexxCompoundElement
Definition: RexxCompoundElement.hpp:50
RexxActivation::tracingResults
bool tracingResults()
Definition: RexxActivation.hpp:350
RANDOM_FACTOR
const uint64_t RANDOM_FACTOR
Definition: RexxActivation.hpp:69
RexxActivation::liveGeneral
void liveGeneral(int reason)
Definition: RexxActivation.cpp:977
RexxActivation::getNext
RexxInstruction * getNext()
Definition: RexxActivation.hpp:360
RexxActivation::currentLine
size_t currentLine()
Definition: RexxActivation.cpp:1184
RexxActivation::getLocalCompoundVariableValue
RexxObject * getLocalCompoundVariableValue(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4163
RexxActivation::transfer_failed
static const size_t transfer_failed
Definition: RexxActivation.hpp:668
RexxActivation::getAddress
RexxString * getAddress()
Definition: RexxActivation.hpp:357
RexxActivation::isTopLevelCall
bool isTopLevelCall()
Definition: RexxActivation.hpp:202
BaseExecutable::getSourceObject
RexxSource * getSourceObject()
Definition: MethodClass.hpp:85
RexxActivation::getLocalCompoundVariable
RexxCompoundElement * getLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4183
RexxActivation::setIndent
void setIndent(size_t v)
Definition: RexxActivation.hpp:346
RexxActivation::getConditionObj
RexxDirectory * getConditionObj()
Definition: RexxActivation.hpp:358
RexxActivation::traceOperatorValue
void traceOperatorValue(int prefix, const char *tag, RexxObject *value)
Definition: RexxActivation.cpp:3323
NumericSettings
Definition: Numerics.hpp:49
RexxActivation::single_step_nested
static const size_t single_step_nested
Definition: RexxActivation.hpp:652
RexxActivation::dropLocalStem
void dropLocalStem(RexxString *name, size_t index)
Definition: RexxActivation.hpp:487
RexxLocalVariables::updateVariable
void updateVariable(RexxVariable *)
Definition: RexxLocalVariables.cpp:289
ExpressionStack.hpp
RexxActivation::yield
void yield()
Definition: RexxActivation.cpp:3652
RexxActivation::forwarded
static const size_t forwarded
Definition: RexxActivation.hpp:662
RexxActivation::getAllLocalVariables
RexxDirectory * getAllLocalVariables()
Definition: RexxActivation.hpp:459
RexxActivation::getLocalVariables
RexxVariableDictionary * getLocalVariables()
Definition: RexxActivation.hpp:454
RexxActivation::signalTo
void signalTo(RexxInstruction *)
Definition: RexxActivation.cpp:1805
RexxLocalVariables::putVariable
void putVariable(RexxVariable *variable, size_t index)
Definition: RexxLocalVariables.hpp:99
RexxSource::instruction
RexxInstruction * instruction()
Definition: SourceFile.cpp:3837
RexxActivation::setLocalCompoundVariable
void setLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount, RexxObject *value)
Definition: RexxActivation.cpp:4231
RexxActivation::getMethodArgument
RexxObject * getMethodArgument(size_t position)
Definition: RexxActivation.hpp:425
RexxActivation::localCompoundVariableExists
bool localCompoundVariableExists(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4203
RexxActivation::getMethodArgumentList
RexxObject ** getMethodArgumentList()
Definition: RexxActivation.hpp:423
RexxActivation::guardOff
void guardOff()
Definition: RexxActivation.hpp:185
memoryObject
RexxMemory memoryObject
Definition: RexxMemory.cpp:84
RexxActivation::getSourceObject
RexxSource * getSourceObject()
Definition: RexxActivation.hpp:325
RexxQueue
Definition: QueueClass.hpp:49
RexxActivation::trapUndelay
void trapUndelay(RexxString *)
Definition: RexxActivation.cpp:2090
RexxActivation::checkTrapTable
void checkTrapTable()
Definition: RexxActivation.cpp:1429
RexxLocalVariables::setDictionary
void setDictionary(RexxVariableDictionary *dict)
Definition: RexxLocalVariables.hpp:137
type
int type
Definition: cmdparse.cpp:1965
RexxActivation::formatSourcelessTraceLine
RexxString * formatSourcelessTraceLine(RexxString *packageName)
Definition: RexxActivation.cpp:4350
RexxVariableDictionary::release
void release(RexxActivity *)
Definition: RexxVariableDictionary.cpp:379
RexxActivation::terminateBlock
void terminateBlock(size_t _indent)
Definition: RexxActivation.hpp:337
ActivationSettings::traceindent
size_t traceindent
Definition: RexxActivation.hpp:124
RexxActivation::tracingCommands
bool tracingCommands(void)
Definition: RexxActivation.hpp:399
StackFrameClass
Definition: StackFrameClass.hpp:59
ActivationSettings::object_variables
RexxVariableDictionary * object_variables
Definition: RexxActivation.hpp:114
RexxActivation::code
RexxCode * code
Definition: RexxActivation.hpp:600
RexxActivation::activity
RexxActivity * activity
Definition: RexxActivation.hpp:604
RexxActivation::trace_suppress
static const size_t trace_suppress
Definition: RexxActivation.hpp:644
RexxActivation::scope
RexxClass * scope
Definition: RexxActivation.hpp:602
RexxActivation::findClass
RexxClass * findClass(RexxString *name)
Definition: RexxActivation.cpp:2762
RexxActivation::pushControl
void pushControl(RexxObject *)
RexxActivation::setDigits
void setDigits()
Definition: RexxActivation.cpp:1940
RexxActivation::getObjectVariables
RexxVariableDictionary * getObjectVariables()
Definition: RexxActivation.cpp:1652
RexxActivation::debug_pause
bool debug_pause
Definition: RexxActivation.hpp:611
RexxActivation::RexxActivation
RexxActivation(RESTORETYPE restoreType)
Definition: RexxActivation.hpp:164
METHODCALL
#define METHODCALL
Definition: RexxActivation.hpp:137
LL
struct _LL LL
ActivationSettings::calltype
RexxString * calltype
Definition: RexxActivation.hpp:115
RexxContext
Definition: ContextClass.hpp:53
RoutineClass
Definition: RoutineClass.hpp:49
RexxActivation::updateLocalVariable
void updateLocalVariable(RexxVariable *variable)
Definition: RexxActivation.hpp:515
RexxActivation::settings
ActivationSettings settings
Definition: RexxActivation.hpp:598
TRACE_PREFIX_PREFIX
Definition: RexxActivity.hpp:88
RexxActivation::trace_off
static const size_t trace_off
Definition: RexxActivation.hpp:635
RexxActivation::tracingFailures
bool tracingFailures(void)
Definition: RexxActivation.hpp:395
ActivityManager.hpp
RexxActivation::clause_boundary
static const size_t clause_boundary
Definition: RexxActivation.hpp:656
RexxActivation::set_trace_off
static const size_t set_trace_off
Definition: RexxActivation.hpp:665
ActivationSettings::parent_method
RexxMethod * parent_method
Definition: RexxActivation.hpp:108
RexxActivation::termination
void termination()
Definition: RexxActivation.cpp:1398
RexxActivation::hasActiveBlocks
bool hasActiveBlocks()
Definition: RexxActivation.hpp:342
RexxActivation::dostack
RexxDoBlock * dostack
Definition: RexxActivation.hpp:608
SCOPE_RESERVED
#define SCOPE_RESERVED
Definition: RexxActivation.hpp:153
ActivationSettings::alternate_env
RexxString * alternate_env
Definition: RexxActivation.hpp:111
RexxActivation::arguments
void arguments(RexxObject *)
RexxActivation::condition_queue
RexxQueue * condition_queue
Definition: RexxActivation.hpp:626
ActivationSettings::securityManager
SecurityManager * securityManager
Definition: RexxActivation.hpp:118
RexxInstructionCallBase
Definition: CallInstruction.hpp:50
RexxActivation::next
RexxInstruction * next
Definition: RexxActivation.hpp:610
RexxCode
Definition: RexxCode.hpp:58
RexxActivation::reply_issued
static const size_t reply_issued
Definition: RexxActivation.hpp:663
RANDOMIZE
uint64_t RANDOMIZE(uint64_t seed)
Definition: RexxActivation.hpp:72
RexxActivation::externalTraceOff
void externalTraceOff()
Definition: RexxActivation.cpp:3675
TRACE_PREFIX_DOTVARIABLE
Definition: RexxActivity.hpp:85
RexxActivation::findRexxContext
virtual RexxActivation * findRexxContext()
Definition: RexxActivation.cpp:2008
RexxActivation::traceResult
void traceResult(RexxObject *v)
Definition: RexxActivation.hpp:392
RexxActivation::pauseLabel
void pauseLabel()
Definition: RexxActivation.hpp:403
RexxInstruction
Definition: RexxInstruction.hpp:54
PROGRAM_LEVEL_CALL
#define PROGRAM_LEVEL_CALL
Definition: RexxActivation.hpp:146
RexxActivation::current
RexxInstruction * current
Definition: RexxActivation.hpp:609
RexxActivation::tracePrefix
void tracePrefix(const char *n, RexxObject *v)
Definition: RexxActivation.hpp:384
RexxActivation::getActivity
RexxActivity * getActivity()
Definition: RexxActivation.hpp:351
TRACE_PREFIX_RESULT
Definition: RexxActivity.hpp:82
RexxVariableDictionary
Definition: RexxVariableDictionary.hpp:55
TRACE_PREFIX_OPERATOR
Definition: RexxActivity.hpp:89
RexxActivation::getCurrent
RexxInstruction * getCurrent()
Definition: RexxActivation.hpp:354
RexxActivation::exitFrom
void exitFrom(RexxObject *)
Definition: RexxActivation.cpp:1326
RexxActivation::iterate
void iterate(RexxString *)
Definition: RexxActivation.cpp:1088
RexxActivation::processClauseBoundary
void processClauseBoundary()
Definition: RexxActivation.cpp:3539
RexxActivation::run
RexxObject * run(RexxObject **_arglist, size_t _argcount, ProtectedObject &_result)
Definition: RexxActivation.hpp:210
RexxVariableBase
Definition: ExpressionBaseVariable.hpp:47
RexxActivation::halt_condition
static const size_t halt_condition
Definition: RexxActivation.hpp:657
RexxActivation::topBlock
RexxDoBlock * topBlock()
Definition: RexxActivation.hpp:336
RexxActivation::getProgramArgument
RexxObject * getProgramArgument(size_t position)
Definition: RexxActivation.hpp:439
RexxActivation::traceIntermediate
void traceIntermediate(RexxObject *v, int p)
Definition: RexxActivation.hpp:373
RexxActivation::trapinfo
RexxArray * trapinfo
Definition: RexxActivation.hpp:614
RexxActivation::createStackFrame
StackFrameClass * createStackFrame()
Definition: RexxActivation.cpp:4300
RexxActivation::trapDelay
void trapDelay(RexxString *)
Definition: RexxActivation.cpp:2074
INTERPRET
#define INTERPRET
Definition: RexxActivation.hpp:139
RexxActivation::traceLabel
void traceLabel(RexxInstruction *v)
Definition: RexxActivation.hpp:397
RexxActivation::traceSourceString
void traceSourceString()
Definition: RexxActivation.cpp:3482
RexxActivationBase::executable
BaseExecutable * executable
Definition: ObjectClass.hpp:603
RexxActivation::assignLocalCompoundVariable
void assignLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount, RexxObject *value)
Definition: RexxActivation.cpp:4213
RexxActivation::trapOn
void trapOn(RexxString *, RexxInstructionCallBase *)
Definition: RexxActivation.cpp:1451
DoBlock.hpp
RexxVariableDictionary::getAllVariables
RexxDirectory * getAllVariables()
Definition: RexxVariableDictionary.cpp:468
RexxActivation::environmentList
RexxList * environmentList
Definition: RexxActivation.hpp:622
RexxActivation::loadRequires
PackageClass * loadRequires(RexxString *, RexxInstruction *)
Definition: RexxActivation.cpp:2805
RexxActivation::lookaside_size
size_t lookaside_size
Definition: RexxActivation.hpp:630
RexxSupplier
Definition: SupplierClass.hpp:47
RexxLocalVariables.hpp
RexxActivation::processTraps
void processTraps()
Definition: RexxActivation.cpp:655
RexxActivation::resetElapsed
void resetElapsed()
Definition: RexxActivation.cpp:2979
RexxActivation::single_step
static const size_t single_step
Definition: RexxActivation.hpp:651
RexxActivationBase
Definition: ObjectClass.hpp:574
RexxActivation::trace_commands
static const size_t trace_commands
Definition: RexxActivation.hpp:640
RexxActivation::isTopLevel
bool isTopLevel()
Definition: RexxActivation.hpp:408
ActivationSettings::traceOption
size_t traceOption
Definition: RexxActivation.hpp:120
RexxActivation::setTrace
void setTrace(size_t, size_t)
Definition: RexxActivation.cpp:772
RexxActivation::getPublicRoutines
RexxDirectory * getPublicRoutines()
Definition: RexxActivation.cpp:4022
RexxActivation::loadLibrary
void loadLibrary(RexxString *target, RexxInstruction *instruction)
Definition: RexxActivation.cpp:2823
RexxActivation::interpret
void interpret(RexxString *)
Definition: RexxActivation.cpp:2352
RexxActivation::adjustRandomSeed
void adjustRandomSeed()
Definition: RexxActivation.hpp:311
RexxActivation::tracingAll
bool tracingAll(void)
Definition: RexxActivation.hpp:400
RexxActivation::clearTraceSettings
void clearTraceSettings()
Definition: RexxActivation.hpp:349
RexxActivation::propagateExit
void propagateExit(RexxObject *)
RexxActivation::internalMethod
bool internalMethod()
RexxActivation::traceClause
void traceClause(RexxInstruction *, int)
Definition: RexxActivation.cpp:3766
RexxActivation::isInternalCall
bool isInternalCall()
Definition: RexxActivation.hpp:198
RexxActivation::isRoutine
bool isRoutine()
Definition: RexxActivation.hpp:200
RexxActivation::trapOff
void trapOff(RexxString *)
Definition: RexxActivation.cpp:1471
RexxActivation::getContextObject
RexxObject * getContextObject()
Definition: RexxActivation.cpp:2469
RexxActivation::getCallname
RexxString * getCallname()
Definition: RexxActivation.hpp:353
RexxActivation::form
bool form()
Definition: RexxActivation.cpp:1929
RexxSource::condition
static int condition(RexxToken *)
Definition: KeywordConstants.cpp:521
RexxActivation::getProgramName
RexxString * getProgramName()
Definition: RexxActivation.cpp:3967
SIZE_BITS
const size_t SIZE_BITS
Definition: RexxActivation.hpp:74
RexxActivation::result
RexxObject * result
Definition: RexxActivation.hpp:613
RexxActivation::traceEntry
void traceEntry()
Definition: RexxActivation.cpp:3147
ActivationSettings::current_env
RexxString * current_env
Definition: RexxActivation.hpp:110
RexxActivation::isProgram
bool isProgram()
Definition: RexxActivation.hpp:201
RexxActivation::trace_flags
static const size_t trace_flags
Definition: RexxActivation.hpp:645
ActivationSettings::streams
RexxDirectory * streams
Definition: RexxActivation.hpp:116
RexxActivation::default_trace_flags
static const size_t default_trace_flags
Definition: RexxActivation.hpp:646
RexxActivation::pauseCommand
void pauseCommand()
Definition: RexxActivation.hpp:404
RexxActivation::tracingIntermediates
bool tracingIntermediates()
Definition: RexxActivation.hpp:348
ActivationSettings::parent_argcount
size_t parent_argcount
Definition: RexxActivation.hpp:107
RexxSource
Definition: SourceFile.hpp:131
ActivationSettings::traps
RexxDirectory * traps
Definition: RexxActivation.hpp:104
RexxActivation::guarded_method
static const size_t guarded_method
Definition: RexxActivation.hpp:671
RexxActivation::traceCompoundAssignment
void traceCompoundAssignment(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value)
Definition: RexxActivation.hpp:391
RexxActivation::traceMessage
void traceMessage(RexxString *n, RexxObject *v)
Definition: RexxActivation.hpp:380
RexxCompoundTail.hpp
RexxActivation::traceFunction
void traceFunction(RexxString *n, RexxObject *v)
Definition: RexxActivation.hpp:378
RexxActivation::getLocalEnvironment
RexxObject * getLocalEnvironment(RexxString *name)
Definition: RexxActivation.cpp:4289
RexxStem
Definition: StemClass.hpp:70
RexxLocalVariables::getDictionary
RexxVariableDictionary * getDictionary()
Definition: RexxLocalVariables.hpp:91
RexxActivation::callMacroSpaceFunction
bool callMacroSpaceFunction(RexxString *, RexxObject **, size_t, RexxString *, int, ProtectedObject &)
Definition: RexxActivation.cpp:2554
RexxDoBlock::getIndent
size_t getIndent()
Definition: DoBlock.hpp:73
TRACE_PREFIX_VARIABLE
Definition: RexxActivity.hpp:84
RexxActivation::novalueEnabled
bool novalueEnabled()
Definition: RexxActivation.hpp:542
RexxActivation::isInterpret
bool isInterpret()
Definition: RexxActivation.hpp:197
RexxDateTime
Definition: RexxDateTime.hpp:110
RexxActivation::directRetriever
RexxVariableBase * directRetriever(RexxString *)
RexxActivation::getRandomSeed
uint64_t getRandomSeed(RexxInteger *)
Definition: RexxActivation.cpp:2997
RexxActivation::unindent
void unindent()
Definition: RexxActivation.hpp:345
RexxActivation::pushBlock
void pushBlock(RexxDoBlock *block)
Definition: RexxActivation.hpp:334
RexxVariable::reset
void reset(RexxString *name)
Definition: RexxVariable.hpp:77
RexxActivation::fuzz
size_t fuzz()
Definition: RexxActivation.cpp:1921
RexxActivation::random
RexxInteger * random(RexxInteger *, RexxInteger *, RexxInteger *)
Definition: RexxActivation.cpp:3034
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
TOP_LEVEL_CALL
#define TOP_LEVEL_CALL
Definition: RexxActivation.hpp:144
RexxActivation::procedureExpose
void procedureExpose(RexxVariableBase **variables, size_t count)
Definition: RexxActivation.cpp:1200
RexxActivation::getContextLine
RexxObject * getContextLine()
Definition: RexxActivation.cpp:2486
RexxActivation::popControl
RexxObject * popControl()
RexxActivity
Definition: RexxActivity.hpp:127
TRACE_PREFIX_CLAUSE
Definition: RexxActivity.hpp:80
RexxActivation::traceOperator
void traceOperator(const char *n, RexxObject *v)
Definition: RexxActivation.hpp:382
RexxActivation::getSettings
void getSettings(ActivationSettings &s)
Definition: RexxActivation.hpp:355
RexxActivation::source_traced
static const size_t source_traced
Definition: RexxActivation.hpp:659
RexxActivation::return_status_set
static const size_t return_status_set
Definition: RexxActivation.hpp:667
RexxDateTime.hpp
RexxDirectory
Definition: DirectoryClass.hpp:49
RexxActivation::getContextLineNumber
size_t getContextLineNumber()
Definition: RexxActivation.cpp:2507
RexxActivation::external
RexxActivation * external()
Definition: RexxActivation.cpp:1492
RexxVariable::cache
void cache(RexxVariable *next)
Definition: RexxVariable.hpp:89
RexxClass
Definition: ClassClass.hpp:49
RexxActivation::debugSkip
void debugSkip(wholenumber_t, bool)
Definition: RexxActivation.cpp:706
PROGRAM_OR_METHOD
#define PROGRAM_OR_METHOD
Definition: RexxActivation.hpp:148
RexxActivation::implicitExit
void implicitExit()
Definition: RexxActivation.hpp:272
RexxActivation::setExternalTraceOn
void setExternalTraceOn()
Definition: RexxActivation.hpp:414
RexxActivation::getElapsed
int64_t getElapsed()
Definition: RexxActivation.cpp:2962
RexxActivation::pauseInstruction
void pauseInstruction()
Definition: RexxActivation.hpp:401
RexxActivation::trace_all
static const size_t trace_all
Definition: RexxActivation.hpp:637
RexxActivation::setLocalVariable
void setLocalVariable(RexxString *name, size_t index, RexxObject *value)
Definition: RexxActivation.hpp:520
ProtectedObject
Definition: ProtectedObject.hpp:46
RexxLocalVariables::lookupStemVariable
RexxVariable * lookupStemVariable(RexxString *name, size_t index)
Definition: RexxLocalVariables.cpp:219
RexxActivation::toggleAddress
void toggleAddress()
Definition: RexxActivation.cpp:1831
RexxActivation::debugPause
bool debugPause(RexxInstruction *instr=OREF_NULL)
Definition: RexxActivation.cpp:3687
RexxActivation::traceCompoundName
void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail)
Definition: RexxActivation.hpp:388
RexxActivation::removeBlock
void removeBlock()
Definition: RexxActivation.hpp:340
RexxActivation::formatTrace
RexxString * formatTrace(RexxInstruction *, RexxSource *)
Definition: RexxActivation.cpp:3513
RexxActivation::procedure_valid
static const size_t procedure_valid
Definition: RexxActivation.hpp:655
RexxActivation::setCurrent
void setCurrent(RexxInstruction *v)
Definition: RexxActivation.hpp:362
RexxActivation::getMacroCode
static RoutineClass * getMacroCode(RexxString *macroName)
Definition: RexxActivation.cpp:2714
RexxActivation::cacheLocalVariable
void cacheLocalVariable(RexxVariable *var)
Definition: RexxActivation.hpp:564
RexxActivation::command
void command(RexxString *, RexxString *)
Definition: RexxActivation.cpp:3805
ASSIGNMENT_MARKER
#define ASSIGNMENT_MARKER
Definition: RexxActivity.hpp:101
ActivationSettings::parent_arglist
RexxObject ** parent_arglist
Definition: RexxActivation.hpp:106
RexxActivation::sourceObject
RexxSource * sourceObject
Definition: RexxActivation.hpp:601
RexxActivation::debug_prompt_issued
static const size_t debug_prompt_issued
Definition: RexxActivation.hpp:653
RexxActivation::objnotify
RexxMessage * objnotify
Definition: RexxActivation.hpp:620
RexxActivation::getReceiver
virtual RexxObject * getReceiver()
Definition: RexxActivation.cpp:2042
RexxLocalVariables::find
RexxVariable * find(RexxString *name, size_t index)
Definition: RexxLocalVariables.hpp:120
RexxActivation::popEnvironment
RexxObject * popEnvironment()
Definition: RexxActivation.cpp:4064
ActivationSettings
Definition: RexxActivation.hpp:99
RexxActivation::traps_copied
static const size_t traps_copied
Definition: RexxActivation.hpp:666
RexxActivation::traceCompound
void traceCompound(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value)
Definition: RexxActivation.hpp:390
RexxLocalVariables::size
size_t size
Definition: RexxLocalVariables.hpp:141
RexxActivity::callTerminationExit
void callTerminationExit(RexxActivation *)
Definition: RexxActivity.cpp:2071
PackageClass
Definition: PackageClass.hpp:48
RexxActivation::traceVariable
void traceVariable(RexxString *n, RexxObject *v)
Definition: RexxActivation.hpp:374
ActivationSettings::trace_skip
wholenumber_t trace_skip
Definition: RexxActivation.hpp:122
RexxActivation::setForm
void setForm()
Definition: RexxActivation.cpp:1974
RexxActivation::isMethod
bool isMethod()
Definition: RexxActivation.hpp:199
ContextClass.hpp
RexxActivation::trace_all_flags
static const size_t trace_all_flags
Definition: RexxActivation.hpp:647
RexxActivation::retriever
RexxVariableBase * retriever(RexxString *)
RexxActivation::traceTaggedValue
void traceTaggedValue(int prefix, const char *tagPrefix, bool quoteTag, RexxString *tag, const char *marker, RexxObject *value)
Definition: RexxActivation.cpp:3232
RexxActivation::expose
void expose(RexxVariableBase **variables, size_t count)
Definition: RexxActivation.cpp:1229
ActivationSettings::flags
size_t flags
Definition: RexxActivation.hpp:121
RexxMessage
Definition: MessageClass.hpp:54
RexxVariable::set
void set(RexxObject *value)
Definition: RexxVariable.hpp:67
RexxActivation::trace_debug
static const size_t trace_debug
Definition: RexxActivation.hpp:636
RexxActivation::getMethodArgumentCount
size_t getMethodArgumentCount()
Definition: RexxActivation.hpp:424
ActivationSettings::timestamp
RexxDateTime timestamp
Definition: RexxActivation.hpp:127
RexxLocalVariables
Definition: RexxLocalVariables.hpp:61
RexxActivation::getLocalStem
RexxStem * getLocalStem(RexxString *name, size_t index)
Definition: RexxActivation.hpp:482
RexxActivation::addLocalRoutine
void addLocalRoutine(RexxString *name, RexxMethod *method)
Definition: RexxActivation.cpp:3999
RexxActivation::trap
bool trap(RexxString *, RexxDirectory *)
Definition: RexxActivation.cpp:2106
RexxActivation::pushEnvironment
void pushEnvironment(RexxObject *)
Definition: RexxActivation.cpp:4039
RexxActivation::getStack
RexxExpressionStack * getStack()
Definition: RexxActivation.hpp:365
RexxActivation::closeStreams
void closeStreams()
Definition: RexxActivation.cpp:4092
RexxActivation::putSettings
void putSettings(ActivationSettings &s)
Definition: RexxActivation.hpp:356
RexxActivation::returnFrom
void returnFrom(RexxObject *result)
Definition: RexxActivation.cpp:1049
RexxActivation::traceCommand
void traceCommand(RexxInstruction *v)
Definition: RexxActivation.hpp:398
RexxActivation::traceValue
void traceValue(RexxObject *, int)
Definition: RexxActivation.cpp:3183
RexxActivation::debugInterpret
void debugInterpret(RexxString *)
Definition: RexxActivation.cpp:2371
RexxCode.hpp
RexxActivation::unwindTrap
void unwindTrap(RexxActivation *)
Definition: RexxActivation.cpp:2314
RexxActivation::signalValue
void signalValue(RexxString *)
Definition: RexxActivation.cpp:1869
RexxActivation::guardOn
void guardOn()
Definition: RexxActivation.cpp:1892
TRACE_PREFIX_MESSAGE
Definition: RexxActivity.hpp:91
RexxActivation::getLocalCompoundVariableRealValue
RexxObject * getLocalCompoundVariableRealValue(RexxString *localstem, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4173
RexxActivation::localVariableExists
bool localVariableExists(RexxString *name, size_t index)
Definition: RexxActivation.hpp:502
RexxActivation::dropLocalVariable
void dropLocalVariable(RexxString *name, size_t index)
Definition: RexxActivation.hpp:526
RexxActivation::trace_intermediates
static const size_t trace_intermediates
Definition: RexxActivation.hpp:639
RexxActivation::execution_state
int execution_state
Definition: RexxActivation.hpp:617
RexxCompoundTail::createCompoundName
RexxString * createCompoundName(RexxString *)
Definition: RexxCompoundTail.cpp:319
RexxActivation::enableExternalTrace
void enableExternalTrace()
Definition: RexxActivation.cpp:3617
RETURNED
#define RETURNED
Definition: RexxActivation.hpp:79
RexxActivation::arglist
RexxObject ** arglist
Definition: RexxActivation.hpp:606
ActivationSettings::intermediate_trace
bool intermediate_trace
Definition: RexxActivation.hpp:128
SCOPE_RELEASED
#define SCOPE_RELEASED
Definition: RexxActivation.hpp:154
RexxActivation::getProgramArgumentCount
size_t getProgramArgumentCount()
Definition: RexxActivation.hpp:437
SecurityManager
Definition: SecurityManager.hpp:52
RexxDoBlock::getPrevious
RexxDoBlock * getPrevious()
Definition: DoBlock.hpp:75
RexxActivation::getEffectiveSecurityManager
SecurityManager * getEffectiveSecurityManager()
Definition: RexxActivation.cpp:4271
RexxActivation::local
RexxDirectory * local()
RexxActivation::isMethodOrRoutine
bool isMethodOrRoutine()
Definition: RexxActivation.hpp:206
RexxActivation::trace_results_flags
static const size_t trace_results_flags
Definition: RexxActivation.hpp:648
RexxActivation::indent
void indent()
Definition: RexxActivation.hpp:344
RexxActivation::internalCallTrap
RexxObject * internalCallTrap(RexxString *, RexxInstruction *, RexxDirectory *, ProtectedObject &)
Definition: RexxActivation.cpp:2874
RexxActivation::blockNest
size_t blockNest
Definition: RexxActivation.hpp:629
RexxVariable::setCreator
void setCreator(RexxActivation *creatorActivation)
Definition: RexxVariable.hpp:87
RexxActivation::activation_context
int activation_context
Definition: RexxActivation.hpp:619
RexxActivation::handleNovalueEvent
RexxObject * handleNovalueEvent(RexxString *name, RexxObject *defaultValue, RexxVariable *variable)
Definition: RexxActivation.cpp:2250
RexxActivation
Definition: RexxActivation.hpp:156
RexxInternalObject::setHasNoReferences
void setHasNoReferences()
Definition: ObjectClass.hpp:240
RexxActivation::inDebug
bool inDebug()
Definition: RexxActivation.hpp:363
RexxActivation::pending_count
size_t pending_count
Definition: RexxActivation.hpp:623
RexxActivation::halt
bool halt(RexxString *)
Definition: RexxActivation.cpp:3632
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
RexxActivation::object_scope
int object_scope
Definition: RexxActivation.hpp:612
RexxActivation::tracingErrors
bool tracingErrors(void)
Definition: RexxActivation.hpp:394
RexxActivation::novalueHandler
RexxObject * novalueHandler(RexxString *)
Definition: RexxActivation.cpp:4117
RexxActivation::stack
RexxExpressionStack stack
Definition: RexxActivation.hpp:599
RexxActivation::traceCompoundValue
void traceCompoundValue(int prefix, RexxString *stemName, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail)
Definition: RexxActivation.cpp:3397
RexxActivation::setDefaultAddress
void setDefaultAddress(RexxString *)
Definition: RexxActivation.cpp:1856
TRACE_PREFIX_COMPOUND
Definition: RexxActivity.hpp:90
RexxActivation::addBlock
void addBlock()
Definition: RexxActivation.hpp:341
RexxActivation::traceCompoundName
void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxString *tail)
Definition: RexxActivation.hpp:389
RexxActivation::reply
void reply(RexxObject *)
Definition: RexxActivation.cpp:1029
RexxActivation::traceDotVariable
void traceDotVariable(RexxString *n, RexxObject *v)
Definition: RexxActivation.hpp:376
RexxActivation::mergeTraps
void mergeTraps(RexxQueue *, RexxQueue *)
Definition: RexxActivation.cpp:2278
RexxActivation::getStreams
RexxDirectory * getStreams()
Definition: RexxActivation.cpp:1770
RexxActivation::trace_labels
static const size_t trace_labels
Definition: RexxActivation.hpp:641
RexxActivation::sourceString
RexxString * sourceString()
Definition: RexxActivation.cpp:3983
RexxActivation::argcount
size_t argcount
Definition: RexxActivation.hpp:607
RexxActivation::digits
size_t digits()
Definition: RexxActivation.cpp:1913
RexxActivation::localStemVariableExists
bool localStemVariableExists(RexxString *stemName, size_t index)
Definition: RexxActivation.hpp:494
RexxActivation::getMessageName
RexxString * getMessageName()
Definition: RexxActivation.hpp:352
RexxActivation::getContextReturnStatus
RexxObject * getContextReturnStatus()
Definition: RexxActivation.cpp:2528
RexxVariable::getNext
RexxVariable * getNext()
Definition: RexxVariable.hpp:88
INTERNAL_LEVEL_CALL
#define INTERNAL_LEVEL_CALL
Definition: RexxActivation.hpp:150
RexxActivation::isProgramLevelCall
bool isProgramLevelCall()
Definition: RexxActivation.hpp:203
RexxActivation::debug_bypass
static const size_t debug_bypass
Definition: RexxActivation.hpp:654
RexxLocalVariables::isNested
bool isNested()
Definition: RexxLocalVariables.hpp:134
VALUE_MARKER
#define VALUE_MARKER
Definition: RexxActivity.hpp:99
RexxActivation::getTraceBack
RexxString * getTraceBack()
Definition: RexxActivation.cpp:2925
TRACE_PREFIX_ASSIGNMENT
Definition: RexxActivity.hpp:93
RexxActivation::traceInstruction
void traceInstruction(RexxInstruction *v)
Definition: RexxActivation.hpp:396
RexxLocalVariables::getNestedDictionary
RexxVariableDictionary * getNestedDictionary()
Definition: RexxLocalVariables.hpp:138
RexxActivation::evaluateLocalCompoundVariable
RexxObject * evaluateLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4145
RexxActivation::setObjNotify
void setObjNotify(RexxMessage *)
Definition: RexxActivation.cpp:4029
RexxActivation::getNumericSettings
virtual NumericSettings * getNumericSettings()
Definition: RexxActivation.cpp:2030
RexxSource::variables
RexxDirectory * variables
Definition: SourceFile.hpp:503
RexxActivation::getEffectiveSourceObject
RexxSource * getEffectiveSourceObject()
Definition: RexxActivation.hpp:326
RexxActivation::setAddress
void setAddress(RexxString *)
Definition: RexxActivation.cpp:1843
RexxActivation::isProgramOrMethod
bool isProgramOrMethod()
Definition: RexxActivation.hpp:205
RexxActivation::dispatch
RexxObject * dispatch()
Definition: RexxActivation.cpp:372
RexxActivation::trace_errors
static const size_t trace_errors
Definition: RexxActivation.hpp:642
RexxActivation::getSecurityManager
SecurityManager * getSecurityManager()
Definition: RexxActivation.cpp:4259
RexxActivation::rexxVariable
RexxObject * rexxVariable(RexxString *)
Definition: RexxActivation.cpp:2404
RexxActivation::getLocalStemVariable
RexxVariable * getLocalStemVariable(RexxString *name, size_t index)
Definition: RexxActivation.hpp:473
RexxActivation::random_set
bool random_set
Definition: RexxActivation.hpp:628
RexxActivation::cleanupLocalVariables
void cleanupLocalVariables()
Definition: RexxActivation.hpp:570
RANDOM_ADDER
const uint64_t RANDOM_ADDER
Definition: RexxActivation.hpp:70
RexxSource::position
void position(size_t, size_t)
Definition: SourceFile.cpp:514
RexxActivation::setFuzz
void setFuzz()
Definition: RexxActivation.cpp:1956
RexxActivation::run
RexxObject * run(RexxObject *_receiver, RexxString *msgname, RexxObject **_arglist, size_t _argcount, RexxInstruction *start, ProtectedObject &resultObj)
Definition: RexxActivation.cpp:383
RexxActivation::inMethod
bool inMethod()
Definition: RexxActivation.hpp:343
RexxActivation::trace_on
static const size_t trace_on
Definition: RexxActivation.hpp:658
RexxActivation::isRexxContext
virtual bool isRexxContext()
Definition: RexxActivation.cpp:2019
RexxActivation::isElapsedTimerReset
bool isElapsedTimerReset()
Definition: RexxActivation.hpp:418
RexxActivation::setConditionObj
void setConditionObj(RexxDirectory *condition)
Definition: RexxActivation.hpp:359
RexxActivation::set_trace_on
static const size_t set_trace_on
Definition: RexxActivation.hpp:664
RexxActivation::setGuarded
void setGuarded()
Definition: RexxActivation.hpp:411
RexxActivation::getLabels
RexxDirectory * getLabels()
Definition: RexxActivation.cpp:3975
PROGRAMCALL
#define PROGRAMCALL
Definition: RexxActivation.hpp:140
RexxActivation::senderActivation
RexxActivation * senderActivation()
Definition: RexxActivation.cpp:2337
RexxActivation::dropLocalCompoundVariable
void dropLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4242
RexxActivation::RexxActivation
RexxActivation()
Definition: RexxActivation.cpp:145
RexxActivation::setElapsedTimerInvalid
void setElapsedTimerInvalid()
Definition: RexxActivation.hpp:419
ActivationSettings::conditionObj
RexxDirectory * conditionObj
Definition: RexxActivation.hpp:105
RexxActivation::getStackFrames
RexxArray * getStackFrames(bool skipFirst)
Definition: RexxActivation.cpp:4382
RexxActivation::getProgramArgumentlist
RexxObject ** getProgramArgumentlist()
Definition: RexxActivation.hpp:436
ActivationSettings::return_status
int return_status
Definition: RexxActivation.hpp:123
RexxActivation::isGuarded
bool isGuarded()
Definition: RexxActivation.hpp:410
new_variable
RexxVariable * new_variable(RexxString *n)
Definition: RexxVariable.hpp:104
RexxActivation::trace_intermediates_flags
static const size_t trace_intermediates_flags
Definition: RexxActivation.hpp:649
RESTORETYPE
RESTORETYPE
Definition: ObjectClass.hpp:80
RexxList
Definition: ListClass.hpp:63
RexxActivation::guardWait
void guardWait()
Definition: RexxActivation.cpp:2894
ActivationSettings::msgname
RexxString * msgname
Definition: RexxActivation.hpp:112
RexxActivation::resolveStream
RexxObject * resolveStream(RexxString *name, bool input, RexxString **fullName, bool *added)
Definition: RexxActivation.cpp:1686
RexxCompoundTail
Definition: RexxCompoundTail.hpp:52
RexxMethod
Definition: MethodClass.hpp:101
RexxActivation::external_yield
static const size_t external_yield
Definition: RexxActivation.hpp:661
RexxActivation::elapsed_reset
static const size_t elapsed_reset
Definition: RexxActivation.hpp:670
INTERNALCALL
#define INTERNALCALL
Definition: RexxActivation.hpp:138
ActivationSettings::halt_description
RexxString * halt_description
Definition: RexxActivation.hpp:117
RexxDoBlock
Definition: DoBlock.hpp:49
RexxActivation::receiver
RexxObject * receiver
Definition: RexxActivation.hpp:603
RexxActivation::setCallType
void setCallType(RexxString *type)
Definition: RexxActivation.hpp:333
RexxActivation::raiseExit
void raiseExit(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *, RexxDirectory *)
Definition: RexxActivation.cpp:1511
RexxActivation::live
void live(size_t)
Definition: RexxActivation.cpp:925
RexxActivation::leaveLoop
void leaveLoop(RexxString *)
Definition: RexxActivation.cpp:1140
RexxActivation::clause_exits
static const size_t clause_exits
Definition: RexxActivation.hpp:660
RexxActivation::processTraceSetting
static size_t processTraceSetting(size_t traceSetting)
Definition: RexxActivation.cpp:858
RexxInteger
Definition: IntegerClass.hpp:56
RexxActivation::externalTraceOn
void externalTraceOn()
Definition: RexxActivation.cpp:3663
ActivationSettings::elapsed_time
int64_t elapsed_time
Definition: RexxActivation.hpp:126
RexxActivation::setNext
void setNext(RexxInstruction *v)
Definition: RexxActivation.hpp:361
RexxLocalVariables::lookupVariable
RexxVariable * lookupVariable(RexxString *name, size_t index)
Definition: RexxLocalVariables.cpp:155
RexxActivation::putLocalVariable
void putLocalVariable(RexxVariable *variable, size_t index)
Definition: RexxActivation.hpp:510
RexxActivation::newLocalVariable
RexxVariable * newLocalVariable(RexxString *name)
Definition: RexxActivation.hpp:550
RexxActivation::setElapsedTimerValid
void setElapsedTimerValid()
Definition: RexxActivation.hpp:420
RexxActivation::getLocalVariable
RexxVariable * getLocalVariable(RexxString *name, size_t index)
Definition: RexxActivation.hpp:464
RexxActivation::conditionalPauseInstruction
int conditionalPauseInstruction()
Definition: RexxActivation.hpp:402
RexxActivation::popBlock
void popBlock()
Definition: RexxActivation.hpp:335
ActivationSettings::scope
RexxObject * scope
Definition: RexxActivation.hpp:119
RexxVariable::getVariableValue
RexxObject * getVariableValue()
Definition: RexxVariable.hpp:72
EXTERNALCALL
#define EXTERNALCALL
Definition: RexxActivation.hpp:141
RexxString::concat
RexxString * concat(RexxString *)
Definition: StringClass.cpp:1172
ActivationSettings::ActivationSettings
ActivationSettings()
Definition: RexxActivation.hpp:102
RexxActivation::isForwarded
bool isForwarded()
Definition: RexxActivation.hpp:409
RexxActivation::exposeLocalCompoundVariable
RexxCompoundElement * exposeLocalCompoundVariable(RexxString *stemName, size_t index, RexxObject **tail, size_t tailCount)
Definition: RexxActivation.cpp:4193
RexxActivation::parent
RexxActivation * parent
Definition: RexxActivation.hpp:605
RexxActivation::terminateBlock
void terminateBlock()
Definition: RexxActivation.hpp:338
RexxObject
Definition: ObjectClass.hpp:311
RexxVariable::isLocal
bool isLocal(RexxActivation *act)
Definition: RexxVariable.hpp:90
RexxActivation::resolveDotVariable
RexxObject * resolveDotVariable(RexxString *name)
Definition: RexxActivation.cpp:2781
RexxActivation::getTime
RexxDateTime getTime()
Definition: RexxActivation.cpp:2931
RexxVariable::drop
void drop()
Definition: RexxVariable.cpp:113
RexxActivation::resolveProgramName
RexxString * resolveProgramName(RexxString *name)
Definition: RexxActivation.cpp:2749
ActivationSettings::parent_code
RexxCode * parent_code
Definition: RexxActivation.hpp:109
RexxActivation::getPackage
PackageClass * getPackage()
Definition: RexxActivation.cpp:4139
RexxString
Definition: StringClass.hpp:119
RexxLocalVariables::get
RexxVariable * get(size_t index)
Definition: RexxLocalVariables.hpp:119
RexxActivation::setLocalVariableDictionary
void setLocalVariableDictionary(RexxVariableDictionary *dict)
Definition: RexxActivation.hpp:594
RexxVariable
Definition: RexxVariable.hpp:49
RexxActivation::random_seed
uint64_t random_seed
Definition: RexxActivation.hpp:627