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)  

ObjectClass.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 ObjectClass.hpp */
40 /* */
41 /* Primitive Object Class Definitions */
42 /* */
43 /******************************************************************************/
44 /******************************************************************************/
45 #ifndef Included_RexxObject
46 #define Included_RexxObject
47 
48 #include "Numerics.hpp"
49 
50 #include <stddef.h>
51 
52  class RexxObject;
53  class RexxInteger;
54  class RexxBehaviour;
55  class RexxCompoundTail;
56  class RexxCompoundElement;
57  class RexxInternalStack;
58  class RexxSupplier;
59  class RexxEnvelope;
61  class RexxNumberString;
62  class RexxMethod;
63  class RexxMessage;
64  class ProtectedObject;
65  class SecurityManager;
66  class BaseExecutable;
67  class RexxActivity;
68 
69 
70  enum
71  {
72  LiveMask = 0xFFFC, // mask for the checking the mark bits
73  MarkMask = 0x0003, // mask use for checking the mark bits
74  OldSpaceBit = 0x0010, // location of the OldSpace bit
75  };
76 
77 typedef size_t HashCode; // a hash code value
78 
79  /* used ofor special constructor */
81 
82 
84 {
85 public:
87  {
88  // copy the relevant state
90  flags = h.flags;
91  return *this;
92  }
93 
94  inline size_t getObjectSize() { return (size_t)objectSize; }
95  inline void setObjectSize(size_t l)
96  {
97  objectSize = l;
98  }
99 
100  inline void makeProxiedObject() { flags |= ProxiedObject; }
101  inline bool requiresProxyObject() { return (flags & ProxiedObject) != 0; }
102  inline void makeProxy() { flags |= ProxyObject; }
103  inline bool isProxyObject() { return (flags & ProxyObject) != 0; }
104  inline void clearObjectMark() { flags &= LiveMask; }
105  inline void setObjectMark(size_t mark) { clearObjectMark(); flags |= mark; }
106  inline bool isObjectMarked(size_t mark) { return (flags & mark) != 0; }
107  inline bool isObjectLive(size_t mark) { return ((size_t)(flags & MarkMask)) == mark; }
108  inline bool isObjectDead(size_t mark) { return ((size_t)(flags & MarkMask)) != mark; }
109  inline void clear() { objectSize = 0; flags = 0; }
110  inline void setOldSpace() { flags |= OldSpaceBit; }
111  inline void clearOldSpace() { flags &= ~OldSpaceBit; }
112  inline void setNewSpace() { clearOldSpace(); }
113  inline bool isOldSpace() { return (flags & OldSpaceBit) != 0; }
114  inline bool isNewSpace() { return (flags & OldSpaceBit) == 0; }
115  inline void setHasNoReferences() { flags |= NoRefBit; }
116  inline void setHasReferences() { flags &= ~NoRefBit; }
117  inline bool hasReferences() { return (flags & NoRefBit) == 0; }
118  inline bool hasNoReferences() { return (flags & NoRefBit) != 0; }
119  inline void setNonPrimitive() { flags |= IsNonPrimitive; }
120  inline void setPrimitive() { flags &= ~IsNonPrimitive; }
121  inline bool isNonPrimitive() { return (flags & IsNonPrimitive) != 0; }
122  inline bool isPrimitive() { return (flags & IsNonPrimitive) == 0; }
123  inline void initHeader(size_t l, size_t mark)
124  {
125  objectSize = l;
126  flags = (uint16_t)mark; // the flags are cleared except for the mark.
127  }
128  inline void initHeader(size_t mark)
129  {
130  flags = (uint16_t)mark; // the flags are cleared except for the mark.
131  }
132 
133 protected:
134  enum
135 
136  {
137  MarkBit1 = 0x0001, // location of the first mark bit. Note: shared with IsNonPrimitive
138  MarkBit2 = 0x0002, // Second of the mark bits
139  ProxiedObject = 0x0004, // This requires a proxy
140  ProxyObject = 0x0008, // This object is a PROXY(String) Obj
141  IsNonPrimitive = 0x0010, // use for flattened objects to indicated behaviour status
142  NoRefBit = 0x0020 // location of No References Bit.
143 
144  };
145 
146  size_t objectSize; // allocated size of the object
147  union
148  {
149  uint16_t flags; // the object flag/type information
150  size_t sizePadding; // padding to make sure this is a full pointer size
151  };
152 
153 };
154 
155 
156  class RexxVirtualBase { /* create first base level class */
157  /* dummy virtual function to force */
158  /* the virtual function table to a */
159  /* specific location. Different */
160  /* compilers place the virtual */
161  /* function table pointer at */
162  /* different locations. This forces */
163  /* to the front location */
164  protected:
165  virtual ~RexxVirtualBase() { ; }
166  virtual void baseVirtual() {;}
167 
168  public:
169  // the following need to be defined at the base virtual level. When
170  // an exception is thrown from within an object constructor, the destructors
171  // unwind and the constructed object just ends up with a virtual base
172  // vft. If the garbage collector sees this, it will crash unless these
173  // are defined at this level.
174  virtual void live(size_t) {;}
175  virtual void liveGeneral(int reason) {;}
176  virtual void flatten(RexxEnvelope *) {;}
177  virtual RexxObject *unflatten(RexxEnvelope *) { return (RexxObject *)this; };
178  };
179 
180 class RexxObject;
181 
182 /******************************************************************************/
183 /* Method pointer special types */
184 /******************************************************************************/
185 
186  typedef RexxObject * (RexxObject::*PCPPM0)();
195  typedef RexxObject * (RexxObject::*PCPPMC1)(RexxObject **, size_t);
196 
197  /* pointer to method function */
198  typedef RexxObject * (RexxObject::*PCPPM)();
199  #define CPPM(n) ((PCPPM)&n)
200 
201 
202 #define OREFSHIFT 3
203  /* generate hash value from OREF */
204 inline uintptr_t HASHOREF(RexxVirtualBase *r) { return ((uintptr_t)r) >> OREFSHIFT; }
205  /* Base Object REXX class */
207  public:
208 
209  void * operator new(size_t, RexxClass *);
210  void * operator new(size_t, RexxClass *, RexxObject **, size_t);
211  inline void *operator new(size_t size, void *ptr) {return ptr;}
212  inline void operator delete(void *) { ; }
213  inline void operator delete(void *p, void *ptr) { }
214  inline RexxInternalObject() {;};
215  /* Following constructor used to */
216  /* reconstruct the Virtual */
217  /* Functiosn table. */
218  /* So it doesn't need to do anything */
219  inline RexxInternalObject(RESTORETYPE restoreType) { ; };
220  virtual ~RexxInternalObject() {;};
221 
222  inline operator RexxObject*() { return (RexxObject *)this; };
223 
224  inline size_t getObjectSize() { return header.getObjectSize(); }
225  inline void setObjectSize(size_t s) { header.setObjectSize(s); }
226  // NB: I hope this doesn't add any padding
227  static inline size_t getObjectHeaderSize() { return sizeof(RexxInternalObject); }
228  inline size_t getObjectDataSize() { return getObjectSize() - getObjectHeaderSize(); }
229  inline void *getObjectDataSpace() { return ((char *)this) + getObjectHeaderSize(); }
230  // these clear everything after the hash value.
231  inline void clearObject() { memset(getObjectDataSpace(), '\0', getObjectDataSize()); }
232  inline void clearObject(size_t l) { memset(getObjectDataSpace(), '\0', l - getObjectHeaderSize()); }
233  inline void setVirtualFunctions(void *t) { *((void **)this) = t; }
234 
235  inline void setInitHeader(size_t s, size_t markword) { header.initHeader(s, markword); }
236  inline void setInitHeader(size_t markword) { header.initHeader(markword); }
237 
238  inline void setObjectLive(size_t markword) { header.setObjectMark(markword); }
241  inline bool hasReferences() { return header.hasReferences(); }
242  inline bool hasNoReferences() { return header.hasNoReferences(); }
243  inline void setPrimitive() { header.setPrimitive(); }
245  inline bool isPrimitive() { return header.isPrimitive(); }
246  inline bool isNonPrimitive() { return header.isNonPrimitive(); }
247  inline bool isObjectMarked(size_t markword) { return header.isObjectMarked(markword); }
248  inline void setObjectMark(size_t markword) { header.setObjectMark(markword); }
250  inline bool isObjectLive(size_t mark) { return header.isObjectLive(mark); }
251  inline bool isObjectDead(size_t mark) { return header.isObjectDead(mark); }
252  inline bool isOldSpace() { return header.isOldSpace(); }
253  inline bool isNewSpace() { return header.isNewSpace(); }
254  inline void setNewSpace() { header.setNewSpace(); }
255  inline void setOldSpace() { header.setOldSpace(); }
257  inline bool isProxyObject() { return header.isProxyObject(); }
258  bool isSubClassOrEnhanced();
259  bool isBaseClass();
260  size_t getObjectTypeNumber();
261  inline RexxBehaviour *getObjectType() { return behaviour; }
262  inline bool isObjectType(RexxBehaviour *b) { return b == behaviour; }
263  inline bool isObjectType(size_t t) { return getObjectTypeNumber() == t; }
264  inline bool isSameType(RexxInternalObject *o) { return behaviour == o->getObjectType(); }
265  inline void setBehaviour(RexxBehaviour *b) { behaviour = b; }
266 
267  virtual RexxObject *makeProxy(RexxEnvelope *);
268  virtual RexxObject *copy();
270  virtual RexxObject *getValue(RexxActivation *) { return OREF_NULL; }
274  virtual void uninit() {;}
275  virtual HashCode hash() { return getHashValue(); }
276  virtual HashCode getHashValue() { return identityHash(); }
277 
278  inline HashCode identityHash() { return HASHOREF(this); }
279 
280  virtual bool truthValue(int);
281  virtual bool logicalValue(logical_t &);
282  virtual RexxString *makeString();
283  virtual void copyIntoTail(RexxCompoundTail *buffer);
284  virtual RexxString *primitiveMakeString();
285  virtual RexxArray *makeArray();
286  virtual RexxString *stringValue();
287  virtual RexxInteger *integerValue(size_t);
288  virtual bool numberValue(wholenumber_t &result, size_t precision);
289  virtual bool numberValue(wholenumber_t &result);
290  virtual bool unsignedNumberValue(stringsize_t &result, size_t precision);
291  virtual bool unsignedNumberValue(stringsize_t &result);
292  virtual bool doubleValue(double &result);
293  virtual RexxNumberString *numberString();
294 
295  virtual bool isEqual(RexxObject *);
296  virtual bool isInstanceOf(RexxClass *);
299 
300  void hasUninit();
301  void removedUninit();
302  void printObject();
303  RexxObject *clone();
304 
305  ObjectHeader header; /* memory management header */
306  RexxBehaviour *behaviour; /* the object's behaviour */
307  };
308 
309 
310 
312  public:
313  void * operator new(size_t, RexxClass *);
314  void * operator new(size_t, RexxClass *, RexxObject **, size_t);
315  void * operator new(size_t size, void *objectPtr) { return objectPtr; };
316  inline void operator delete(void *, void *) {;}
317  inline void operator delete(void *) {;}
318  inline void operator delete(void *, RexxClass *) {;}
319  inline void operator delete(void *, RexxClass *, RexxObject **, size_t) {;}
320  // Followin are used to create new objects.
321  // Assumed that the message is sent to a class Object
322  // These may move to RexxClass in the future......
323  RexxObject *newRexx(RexxObject **arguments, size_t argCount);
324  RexxObject *newObject() {return new ((RexxClass *)this) RexxObject; };
325 
326  operator RexxInternalObject*() { return (RexxInternalObject *)this; };
327  inline RexxObject(){;};
328  /* Following constructor used to */
329  /* reconstruct the Virtual */
330  /* Functiosn table. */
331  /* So it doesn't need to do anythin*/
332  inline RexxObject(RESTORETYPE restoreType) { ; };
333 
334 
335  // The following two methods probably should be on RexxInternalObject, but they
336  // need to reference the objectVariables field. That field could be moved to
337  // RexxInternalObject, but it would increase the size of all internal objects
338  // by 4 bytes. Since the minimum object size is large enough to always have
339  // that field, it's safe to clear this here.
340  inline void initializeNewObject(size_t size, size_t mark, void *vft, RexxBehaviour *b)
341  {
342  // we need to make this a function object of some type in case
343  // a GC cycle gets triggered before this is complete. By default,
344  // we make this a generic object
345  setVirtualFunctions(vft);
346  setBehaviour(b);
347  // this has a clean set of flags, except for the live mark
348  header.initHeader(size, mark);
349  // make sure the object is cleared in case this gets marked out of any of
350  // the constructors.
351  clearObject();
352  }
353 
354  inline void initializeNewObject(size_t mark, void *vft, RexxBehaviour *b)
355  {
356  // we need to make this a function object of some type in case
357  // a GC cycle gets triggered before this is complete. By default,
358  // we make this a generic object
359  setVirtualFunctions(vft);
360  setBehaviour(b);
361  // this has a clean set of flags, except for the live mark
362  header.initHeader(mark);
363  // make sure the object is cleared in case this gets marked out of any of
364  // the constructors.
365  clearObject();
366  }
367 
368  virtual ~RexxObject(){;};
369 
371  virtual RexxString *defaultName();
372  virtual RexxObject *unknown(RexxString *msg, RexxArray *args){return OREF_NULL;};
373  virtual RexxInteger *hasMethod(RexxString *msg);
374  bool hasUninitMethod();
375 
376  RexxObject *init();
377  void uninit();
378  void live(size_t);
379  void liveGeneral(int reason);
380  void flatten(RexxEnvelope *);
381  RexxObject *copy();
382  HashCode hash();
383  bool truthValue(int);
384  virtual bool logicalValue(logical_t &);
385  virtual bool numberValue(wholenumber_t &result, size_t precision);
386  virtual bool numberValue(wholenumber_t &result);
387  virtual bool unsignedNumberValue(stringsize_t &result, size_t precision);
388  virtual bool unsignedNumberValue(stringsize_t &result);
389  virtual bool doubleValue(double &result);
391  RexxInteger *integerValue(size_t);
394  void copyIntoTail(RexxCompoundTail *buffer);
395  RexxArray *makeArray();
399  RexxInteger *requestInteger(size_t);
400  bool requestNumber(wholenumber_t &, size_t);
401  bool requestUnsignedNumber(stringsize_t &, size_t);
403  RexxString *requiredString(size_t);
404  RexxString *requiredString(const char *);
406  RexxInteger *requiredInteger(size_t, size_t);
407  wholenumber_t requiredNumber(size_t position, size_t precision = Numerics::ARGUMENT_DIGITS);
408  stringsize_t requiredPositive(size_t position, size_t precision = Numerics::ARGUMENT_DIGITS);
409  stringsize_t requiredNonNegative(size_t position, size_t precision = Numerics::ARGUMENT_DIGITS);
410 
411  bool isEqual(RexxObject *);
412  bool isInstanceOf(RexxClass *);
424  RexxMessage *start(RexxObject **, size_t);
426  RexxObject *send(RexxObject **, size_t);
428  RexxMessage *startCommon(RexxObject *message, RexxObject **arguments, size_t argCount);
429  static void decodeMessageName(RexxObject *target, RexxObject *message, RexxString *&messageName, RexxObject *&startScope);
430  RexxString *oref();
431  RexxObject *pmdict();
432  RexxObject *run(RexxObject **, size_t);
433 
434  void messageSend(RexxString *, RexxObject **, size_t, ProtectedObject &);
435  void messageSend(RexxString *, RexxObject **, size_t, RexxObject *, ProtectedObject &);
437  void processUnknown(RexxString *, RexxObject **, size_t, ProtectedObject &);
440  inline void sendMessage(RexxString *message, ProtectedObject &result) { this->messageSend(message, OREF_NULL, 0, result); };
441  inline void sendMessage(RexxString *message, RexxObject **args, size_t argCount, ProtectedObject &result) { this->messageSend(message, args, argCount, result); };
442  inline void sendMessage(RexxString *message, RexxObject *argument1, ProtectedObject &result)
443  { this->messageSend(message, &argument1, 1, result); }
448 
450  RexxObject *sendMessage(RexxString *message);
451  RexxObject *sendMessage(RexxString *message, RexxObject **args, size_t argCount);
452  RexxObject *sendMessage(RexxString *message, RexxObject *argument1);
457 
458  // Following are internal OREXX methods
467  RexxObject *mdict();
469  inline RexxBehaviour *behaviourObject() { return this->behaviour; }
470 
471  const char *idString();
472  RexxString *id();
475  void guardOn(RexxActivity *activity, RexxObject *scope);
476  void guardOff(RexxActivity *activity, RexxObject *scope);
478  RexxObject *notEqual(RexxObject *other);
481 
483 
484  RexxObject *hashCode();
485 
492  RexxObject *copyRexx();
495  void *getCSelf();
496  void *getCSelf(RexxObject *scope);
497  // compare 2 values for equality, potentially falling back on the
498  // "==" method for the test.
499  bool inline equalValue(RexxObject *other)
500  {
501  // test first for direct equality, followed by value equality.
502  return (this == other) || this->isEqual(other);
503  }
505 
506  // Define operator methods here.
507 
508  koper (operator_plus)
509  koper (operator_minus)
510  koper (operator_multiply)
511  koper (operator_divide)
512  koper (operator_integerDivide)
513  koper (operator_remainder)
514  koper (operator_power)
515  koper (operator_abuttal)
516  koper (operator_concat)
517  koper (operator_concatBlank)
518  koper (operator_equal)
519  koper (operator_notEqual)
520  koper (operator_isGreaterThan)
521  koper (operator_isBackslashGreaterThan)
522  koper (operator_isLessThan)
523  koper (operator_isBackslashLessThan)
524  koper (operator_isGreaterOrEqual)
525  koper (operator_isLessOrEqual)
526  koper (operator_strictEqual)
527  koper (operator_strictNotEqual)
528  koper (operator_strictGreaterThan)
529  koper (operator_strictBackslashGreaterThan)
530  koper (operator_strictLessThan)
531  koper (operator_strictBackslashLessThan)
532  koper (operator_strictGreaterOrEqual)
533  koper (operator_strictLessOrEqual)
534  koper (operator_lessThanGreaterThan)
535  koper (operator_greaterThanLessThan)
536  koper (operator_and)
537  koper (operator_or)
538  koper (operator_xor)
539  koper (operator_not)
540 
541  RexxVariableDictionary *objectVariables; /* set of object variables */
543 
544  static void createInstance();
546 };
547 
548 
549 
550 
551 class RexxNilObject : public RexxObject {
552 public:
553  void * operator new(size_t);
554  void * operator new(size_t size, void *objectPtr) { return objectPtr; };
555  inline void operator delete(void *) { ; }
556  inline void operator delete(void *, void *) { ; }
557  RexxNilObject();
558  inline RexxNilObject(RESTORETYPE restoreType) { ; };
559  virtual ~RexxNilObject() {;};
560 
561  virtual HashCode getHashValue();
562 
564 
565 protected:
566  // we want .NIL to have a static hash value after the image restore, so
567  // this needs to be included in the object state
569 };
570 
571 class RexxList;
572 
573 
575 public:
576  inline RexxActivationBase() {;};
577  inline RexxActivationBase(RESTORETYPE restoreType) { ; };
578  virtual RexxObject *dispatch() {return NULL;};
579  virtual size_t digits() {return Numerics::DEFAULT_DIGITS;};
580  virtual size_t fuzz() {return Numerics::DEFAULT_FUZZ;};
581  virtual bool form() {return Numerics::DEFAULT_FORM;};
583  virtual RexxActivation *getRexxContext() { return OREF_NULL; }
584  virtual RexxActivation *findRexxContext() { return OREF_NULL; }
585  virtual void setDigits(size_t) {;};
586  virtual void setFuzz(size_t) {;};
587  virtual void setForm(bool) {;}
588  virtual bool trap(RexxString *, RexxDirectory *) {return false;};
589  virtual void setObjNotify(RexxMessage *) {;};
590  virtual void termination(){;};
591  virtual SecurityManager *getSecurityManager() = 0;
592  virtual bool isForwarded() { return false; }
593  virtual bool isStackBase() { return false; }
594  virtual bool isRexxContext() { return false; }
595  virtual RexxObject *getReceiver() { return OREF_NULL; }
600 
601 protected:
604 
605 };
606 
607 
612 {
613 public:
615  {
616  // just acquire the scope
618  }
619 
620  inline ~GuardLock()
621  {
623  }
624 
625 private:
626  RexxActivity *activity; // the activity we're running on
627  RexxObject *target; // the target object for the lock
628  RexxObject *scope; // the scope of the required guard lock
629 };
630 #endif
RexxInternalObject::logicalValue
virtual bool logicalValue(logical_t &)
Definition: ObjectClass.cpp:437
RexxObject::defMethods
RexxObject * defMethods(RexxDirectory *)
Definition: ObjectClass.cpp:1972
RexxObject::makeString
RexxString * makeString()
Definition: ObjectClass.cpp:1070
RexxActivationBase::getRexxContext
virtual RexxActivation * getRexxContext()
Definition: ObjectClass.hpp:583
ObjectHeader::clear
void clear()
Definition: ObjectClass.hpp:109
GuardLock::~GuardLock
~GuardLock()
Definition: ObjectClass.hpp:620
ObjectHeader::makeProxiedObject
void makeProxiedObject()
Definition: ObjectClass.hpp:100
RexxObject::copy
RexxObject * copy()
Definition: ObjectClass.cpp:518
ObjectHeader::isObjectMarked
bool isObjectMarked(size_t mark)
Definition: ObjectClass.hpp:106
RexxObject::sendMessage
void sendMessage(RexxString *, RexxArray *, ProtectedObject &)
Definition: ObjectClass.cpp:668
RexxExpressionStack
Definition: ExpressionStack.hpp:53
logical_t
size_t logical_t
Definition: rexx.h:230
RexxInternalObject::isObjectType
bool isObjectType(RexxBehaviour *b)
Definition: ObjectClass.hpp:262
ObjectHeader::setObjectMark
void setObjectMark(size_t mark)
Definition: ObjectClass.hpp:105
RexxObject::idString
const char * idString()
Definition: ObjectClass.cpp:2224
MOBILEUNFLATTEN
Definition: ObjectClass.hpp:80
RexxArray
Definition: ArrayClass.hpp:100
RexxInternalObject::setNonPrimitive
void setNonPrimitive()
Definition: ObjectClass.hpp:244
RexxObject::decodeMessageName
static void decodeMessageName(RexxObject *target, RexxObject *message, RexxString *&messageName, RexxObject *&startScope)
Definition: ObjectClass.cpp:1811
RexxCompoundElement
Definition: RexxCompoundElement.hpp:50
MarkMask
Definition: ObjectClass.hpp:73
RexxInternalObject::evaluate
virtual RexxObject * evaluate(RexxActivation *, RexxExpressionStack *)
Definition: ObjectClass.hpp:269
RexxInternalObject::numberValue
virtual bool numberValue(wholenumber_t &result, size_t precision)
Definition: ObjectClass.cpp:922
RexxObject::unknownRexx
RexxObject * unknownRexx(RexxString *, RexxArray *)
Definition: ObjectClass.cpp:2501
RexxObject::isInstanceOf
bool isInstanceOf(RexxClass *)
Definition: ObjectClass.cpp:226
RexxActivationBase::getNumericSettings
virtual NumericSettings * getNumericSettings()
Definition: ObjectClass.hpp:582
NumericSettings
Definition: Numerics.hpp:49
ObjectHeader::hasNoReferences
bool hasNoReferences()
Definition: ObjectClass.hpp:118
RexxObject::initializeNewObject
void initializeNewObject(size_t size, size_t mark, void *vft, RexxBehaviour *b)
Definition: ObjectClass.hpp:340
RexxVirtualBase::liveGeneral
virtual void liveGeneral(int reason)
Definition: ObjectClass.hpp:175
RexxObject::objectName
RexxString * objectName()
Definition: ObjectClass.cpp:1479
ObjectHeader::getObjectSize
size_t getObjectSize()
Definition: ObjectClass.hpp:94
RexxObject::truthValue
bool truthValue(int)
Definition: ObjectClass.cpp:468
RexxObject::stringRexx
RexxString * stringRexx()
Definition: ObjectClass.cpp:2461
RexxObject::newRexx
RexxObject * newRexx(RexxObject **arguments, size_t argCount)
Definition: ObjectClass.cpp:2299
RexxInternalObject
Definition: ObjectClass.hpp:206
RexxInternalObject::getObjectType
RexxBehaviour * getObjectType()
Definition: ObjectClass.hpp:261
RexxObject::checkPrivate
RexxMethod * checkPrivate(RexxMethod *)
Definition: ObjectClass.cpp:565
ObjectHeader::clearOldSpace
void clearOldSpace()
Definition: ObjectClass.hpp:111
RexxObject::guardOn
void guardOn(RexxActivity *activity, RexxObject *scope)
Definition: ObjectClass.cpp:2203
RexxInternalObject::isNewSpace
bool isNewSpace()
Definition: ObjectClass.hpp:253
RexxObject::defaultName
virtual RexxString * defaultName()
Definition: ObjectClass.cpp:1520
RexxObject::equalValue
bool equalValue(RexxObject *other)
Definition: ObjectClass.hpp:499
RexxInternalObject::behaviour
RexxBehaviour * behaviour
Definition: ObjectClass.hpp:306
RexxInternalObject::makeProxy
virtual RexxObject * makeProxy(RexxEnvelope *)
Definition: ObjectClass.cpp:106
RexxObject::strictNotEqual
RexxObject * strictNotEqual(RexxObject *other)
Definition: ObjectClass.cpp:411
RexxInternalObject::setPrimitive
void setPrimitive()
Definition: ObjectClass.hpp:243
RexxInternalObject::getObjectHeaderSize
static size_t getObjectHeaderSize()
Definition: ObjectClass.hpp:227
RexxInternalObject::isSameType
bool isSameType(RexxInternalObject *o)
Definition: ObjectClass.hpp:264
RexxActivationBase::previous
RexxActivationBase * previous
Definition: ObjectClass.hpp:602
OREFSHIFT
#define OREFSHIFT
Definition: ObjectClass.hpp:202
RexxInternalObject::uninit
virtual void uninit()
Definition: ObjectClass.hpp:274
RexxObject::copyRexx
RexxObject * copyRexx()
Definition: ObjectClass.cpp:2493
RexxObject::requestRexx
RexxObject * requestRexx(RexxString *)
Definition: ObjectClass.cpp:1631
RexxActivationBase::getSecurityManager
virtual SecurityManager * getSecurityManager()=0
RexxNilObject
Definition: ObjectClass.hpp:551
RexxActivationBase::setPreviousStackFrame
void setPreviousStackFrame(RexxActivationBase *p)
Definition: ObjectClass.hpp:596
RexxInternalObject::getObjectTypeNumber
size_t getObjectTypeNumber()
Definition: ObjectClass.cpp:2058
RexxObject::requiredInteger
RexxInteger * requiredInteger(size_t, size_t)
Definition: ObjectClass.cpp:1314
RexxInternalObject::clone
RexxObject * clone()
Definition: ObjectClass.cpp:2308
RexxInternalObject::copy
virtual RexxObject * copy()
Definition: ObjectClass.cpp:478
ObjectHeader::makeProxy
void makeProxy()
Definition: ObjectClass.hpp:102
Numerics::getDefaultSettings
static NumericSettings * getDefaultSettings()
Definition: Numerics.hpp:114
RexxInternalObject::hasNoReferences
bool hasNoReferences()
Definition: ObjectClass.hpp:242
RexxActivationBase::setForm
virtual void setForm(bool)
Definition: ObjectClass.hpp:587
LiveMask
Definition: ObjectClass.hpp:72
ObjectHeader::isNonPrimitive
bool isNonPrimitive()
Definition: ObjectClass.hpp:121
ObjectHeader::hasReferences
bool hasReferences()
Definition: ObjectClass.hpp:117
RexxActivationBase::fuzz
virtual size_t fuzz()
Definition: ObjectClass.hpp:580
RexxObject::hasUninitMethod
bool hasUninitMethod()
Definition: ObjectClass.cpp:2291
RexxObject::compareTo
virtual wholenumber_t compareTo(RexxObject *)
Definition: ObjectClass.cpp:186
RexxObject::messageSend
void messageSend(RexxString *, RexxObject **, size_t, ProtectedObject &)
Definition: ObjectClass.cpp:759
RexxNilObject::RexxNilObject
RexxNilObject()
Definition: ObjectClass.cpp:2533
RexxInternalObject::isProxyObject
bool isProxyObject()
Definition: ObjectClass.hpp:257
RexxInternalObject::isEqual
virtual bool isEqual(RexxObject *)
Definition: ObjectClass.cpp:121
RexxObject::doubleValue
virtual bool doubleValue(double &result)
Definition: ObjectClass.cpp:999
RexxActivationBase::setDigits
virtual void setDigits(size_t)
Definition: ObjectClass.hpp:585
RexxObject::superMethod
RexxMethod * superMethod(RexxString *, RexxObject *)
Definition: ObjectClass.cpp:2160
RexxObject::getObjectVariables
RexxVariableDictionary * getObjectVariables(RexxObject *)
Definition: ObjectClass.cpp:2170
RexxObject::methodLookup
RexxMethod * methodLookup(RexxString *name)
Definition: ObjectClass.cpp:897
RexxObject::hash
HashCode hash()
Definition: ObjectClass.cpp:371
RexxObject::strictEqual
RexxObject * strictEqual(RexxObject *)
Definition: ObjectClass.cpp:389
RexxObject::id
RexxString * id()
Definition: ObjectClass.cpp:2240
RexxVariableDictionary
Definition: RexxVariableDictionary.hpp:55
Numerics.hpp
RexxObject::getCSelf
void * getCSelf()
Definition: ObjectClass.cpp:2554
RexxObject::guardOff
void guardOff(RexxActivity *activity, RexxObject *scope)
Definition: ObjectClass.cpp:2216
RexxObject::concatRexx
RexxString * concatRexx(RexxObject *)
Definition: ObjectClass.cpp:2438
ObjectHeader::MarkBit2
Definition: ObjectClass.hpp:138
RexxInternalObject::hasUninit
void hasUninit()
Definition: ObjectClass.cpp:1873
RexxInternalObject::setNewSpace
void setNewSpace()
Definition: ObjectClass.hpp:254
RexxInternalObject::isInstanceOf
virtual bool isInstanceOf(RexxClass *)
Definition: ObjectClass.cpp:212
RexxInternalObject::setOldSpace
void setOldSpace()
Definition: ObjectClass.hpp:255
RexxObject::startWith
RexxMessage * startWith(RexxObject *, RexxArray *)
Definition: ObjectClass.cpp:1740
RexxInternalObject::getRealValue
virtual RexxObject * getRealValue(RexxVariableDictionary *)
Definition: ObjectClass.hpp:273
HASHOREF
uintptr_t HASHOREF(RexxVirtualBase *r)
Definition: ObjectClass.hpp:204
ObjectHeader::setOldSpace
void setOldSpace()
Definition: ObjectClass.hpp:110
RexxInternalObject::isObjectType
bool isObjectType(size_t t)
Definition: ObjectClass.hpp:263
RexxActivationBase::executable
BaseExecutable * executable
Definition: ObjectClass.hpp:603
RexxInternalObject::hash
virtual HashCode hash()
Definition: ObjectClass.hpp:275
RexxActivationBase::isForwarded
virtual bool isForwarded()
Definition: ObjectClass.hpp:592
RexxObject::getObjectVariable
RexxObject * getObjectVariable(RexxString *)
Definition: ObjectClass.cpp:2083
RexxObject::RexxObject
RexxObject(RESTORETYPE restoreType)
Definition: ObjectClass.hpp:332
RexxVirtualBase
Definition: ObjectClass.hpp:156
RexxObject::operatorMethods
static PCPPM operatorMethods[]
Definition: ObjectClass.hpp:542
RexxInternalObject::~RexxInternalObject
virtual ~RexxInternalObject()
Definition: ObjectClass.hpp:220
RexxObject::uninit
void uninit()
Definition: ObjectClass.cpp:2279
RexxSupplier
Definition: SupplierClass.hpp:47
RexxInternalObject::makeProxiedObject
void makeProxiedObject()
Definition: ObjectClass.hpp:256
RexxActivationBase
Definition: ObjectClass.hpp:574
RESTOREIMAGE
Definition: ObjectClass.hpp:80
RexxEnvelope
Definition: RexxEnvelope.hpp:53
RexxObject::notEqual
RexxObject * notEqual(RexxObject *other)
Definition: ObjectClass.cpp:420
PCPPM4
RexxObject *(RexxObject::* PCPPM4)(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: ObjectClass.hpp:190
RexxInternalObject::identityHash
HashCode identityHash()
Definition: ObjectClass.hpp:278
RexxInternalObject::clearObject
void clearObject()
Definition: ObjectClass.hpp:231
RexxInternalObject::RexxInternalObject
RexxInternalObject()
Definition: ObjectClass.hpp:214
RexxInternalObject::isObjectDead
bool isObjectDead(size_t mark)
Definition: ObjectClass.hpp:251
RexxInternalObject::isSubClassOrEnhanced
bool isSubClassOrEnhanced()
Definition: ObjectClass.cpp:158
RexxObject::sendMessage
void sendMessage(RexxString *message, RexxObject *argument1, ProtectedObject &result)
Definition: ObjectClass.hpp:442
RexxInternalStack
Definition: RexxInternalStack.hpp:48
ObjectHeader::isNewSpace
bool isNewSpace()
Definition: ObjectClass.hpp:114
ObjectHeader::objectSize
size_t objectSize
Definition: ObjectClass.hpp:146
RexxActivationBase::RexxActivationBase
RexxActivationBase(RESTORETYPE restoreType)
Definition: ObjectClass.hpp:577
PCPPM3
RexxObject *(RexxObject::* PCPPM3)(RexxObject *, RexxObject *, RexxObject *)
Definition: ObjectClass.hpp:189
RexxNilObject::~RexxNilObject
virtual ~RexxNilObject()
Definition: ObjectClass.hpp:559
RexxInternalObject::getObjectDataSpace
void * getObjectDataSpace()
Definition: ObjectClass.hpp:229
RexxObject::koper
koper(operator_plus) koper(operator_minus) koper(operator_multiply) koper(operator_divide) koper(operator_integerDivide) koper(operator_remainder) koper(operator_power) koper(operator_abuttal) koper(operator_concat) koper(operator_concatBlank) koper(operator_equal) koper(operator_notEqual) koper(operator_isGreaterThan) koper(operator_isBackslashGreaterThan) koper(operator_isLessThan) koper(operator_isBackslashLessThan) koper(operator_isGreaterOrEqual) koper(operator_isLessOrEqual) koper(operator_strictEqual) koper(operator_strictNotEqual) koper(operator_strictGreaterThan) koper(operator_strictBackslashGreaterThan) koper(operator_strictLessThan) koper(operator_strictBackslashLessThan) koper(operator_strictGreaterOrEqual) koper(operator_strictLessOrEqual) koper(operator_lessThanGreaterThan) koper(operator_greaterThanLessThan) koper(operator_and) koper(operator_or) koper(operator_xor) koper(operator_not) RexxVariableDictionary *objectVariables
RexxBehaviour
Definition: RexxBehaviour.hpp:49
ObjectHeader::isPrimitive
bool isPrimitive()
Definition: ObjectClass.hpp:122
RexxObject::makeArrayRexx
RexxObject * makeArrayRexx()
Definition: ObjectClass.cpp:2477
RexxActivationBase::isRexxContext
virtual bool isRexxContext()
Definition: ObjectClass.hpp:594
RexxVirtualBase::~RexxVirtualBase
virtual ~RexxVirtualBase()
Definition: ObjectClass.hpp:165
RexxObject::initializeNewObject
void initializeNewObject(size_t mark, void *vft, RexxBehaviour *b)
Definition: ObjectClass.hpp:354
RexxInternalObject::makeArray
virtual RexxArray * makeArray()
Definition: ObjectClass.cpp:1103
ObjectHeader::clearObjectMark
void clearObjectMark()
Definition: ObjectClass.hpp:104
RexxObject::send
RexxObject * send(RexxObject **, size_t)
Definition: ObjectClass.cpp:1705
ObjectHeader::isObjectLive
bool isObjectLive(size_t mark)
Definition: ObjectClass.hpp:107
RexxObject::objectNameEquals
RexxObject * objectNameEquals(RexxObject *)
Definition: ObjectClass.cpp:1504
RexxActivationBase::getExecutable
BaseExecutable * getExecutable()
Definition: ObjectClass.hpp:598
RexxInternalObject::integerValue
virtual RexxInteger * integerValue(size_t)
Definition: ObjectClass.cpp:946
RexxObject::createInstance
static void createInstance()
Definition: ObjectClass.cpp:72
PCPPM1
RexxObject *(RexxObject::* PCPPM1)(RexxObject *)
Definition: ObjectClass.hpp:187
Numerics::ARGUMENT_DIGITS
static const size_t ARGUMENT_DIGITS
Definition: Numerics.hpp:68
RexxObject::integerValue
RexxInteger * integerValue(size_t)
Definition: ObjectClass.cpp:1008
RexxInternalObject::numberString
virtual RexxNumberString * numberString()
Definition: ObjectClass.cpp:955
RexxInternalObject::getObjectSize
size_t getObjectSize()
Definition: ObjectClass.hpp:224
RexxInternalObject::removedUninit
void removedUninit()
Definition: ObjectClass.cpp:2066
RexxInternalObject::setObjectSize
void setObjectSize(size_t s)
Definition: ObjectClass.hpp:225
RexxInternalObject::clearObject
void clearObject(size_t l)
Definition: ObjectClass.hpp:232
RexxActivationBase::RexxActivationBase
RexxActivationBase()
Definition: ObjectClass.hpp:576
RexxObject::concatBlank
RexxString * concatBlank(RexxObject *)
Definition: ObjectClass.cpp:2454
ObjectHeader::isOldSpace
bool isOldSpace()
Definition: ObjectClass.hpp:113
RexxObject::processUnknown
void processUnknown(RexxString *, RexxObject **, size_t, ProtectedObject &)
Definition: ObjectClass.cpp:862
RexxObject::requestNumber
bool requestNumber(wholenumber_t &, size_t)
Definition: ObjectClass.cpp:1352
RexxInternalObject::setHasReferences
void setHasReferences()
Definition: ObjectClass.hpp:239
RexxObject::copyIntoTail
void copyIntoTail(RexxCompoundTail *buffer)
Definition: ObjectClass.cpp:1084
HashCode
size_t HashCode
Definition: ObjectClass.hpp:77
ObjectHeader::setObjectSize
void setObjectSize(size_t l)
Definition: ObjectClass.hpp:95
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
RexxObject::requiredNumber
wholenumber_t requiredNumber(size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
Definition: ObjectClass.cpp:1392
ObjectHeader::isProxyObject
bool isProxyObject()
Definition: ObjectClass.hpp:103
ObjectHeader::setNonPrimitive
void setNonPrimitive()
Definition: ObjectClass.hpp:119
RexxVirtualBase::flatten
virtual void flatten(RexxEnvelope *)
Definition: ObjectClass.hpp:176
ObjectHeader::flags
uint16_t flags
Definition: ObjectClass.hpp:149
ObjectHeader::ProxiedObject
Definition: ObjectClass.hpp:139
RexxObject::pmdict
RexxObject * pmdict()
RexxActivity
Definition: RexxActivity.hpp:127
RexxObject::init
RexxObject * init()
Definition: ObjectClass.cpp:2257
RexxObject::primitiveMakeString
RexxString * primitiveMakeString()
Definition: ObjectClass.cpp:1095
RexxInternalObject::instanceMethod
virtual RexxMethod * instanceMethod(RexxString *)
Definition: ObjectClass.cpp:255
RexxInternalObject::RexxInternalObject
RexxInternalObject(RESTORETYPE restoreType)
Definition: ObjectClass.hpp:219
RexxInternalObject::getRealValue
virtual RexxObject * getRealValue(RexxActivation *)
Definition: ObjectClass.hpp:272
RexxInternalObject::instanceMethods
virtual RexxSupplier * instanceMethods(RexxClass *)
Definition: ObjectClass.cpp:295
RexxDirectory
Definition: DirectoryClass.hpp:49
PCPPM0
RexxObject *(RexxObject::* PCPPM0)()
Definition: ObjectClass.hpp:186
RexxObject::behaviourObject
RexxBehaviour * behaviourObject()
Definition: ObjectClass.hpp:469
RexxInternalObject::setVirtualFunctions
void setVirtualFunctions(void *t)
Definition: ObjectClass.hpp:233
Numerics::DEFAULT_FORM
static const bool DEFAULT_FORM
Definition: Numerics.hpp:81
RexxObject::requestUnsignedNumber
bool requestUnsignedNumber(stringsize_t &, size_t)
Definition: ObjectClass.cpp:1376
RexxClass
Definition: ClassClass.hpp:49
ObjectHeader::NoRefBit
Definition: ObjectClass.hpp:142
RexxInternalObject::setBehaviour
void setBehaviour(RexxBehaviour *b)
Definition: ObjectClass.hpp:265
OldSpaceBit
Definition: ObjectClass.hpp:74
RexxInternalObject::doubleValue
virtual bool doubleValue(double &result)
Definition: ObjectClass.cpp:938
RexxObject::requiredNonNegative
stringsize_t requiredNonNegative(size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
Definition: ObjectClass.cpp:1442
RexxObject::flatten
void flatten(RexxEnvelope *)
Definition: ObjectClass.cpp:94
ObjectHeader::setPrimitive
void setPrimitive()
Definition: ObjectClass.hpp:120
RexxObject::startCommon
RexxMessage * startCommon(RexxObject *message, RexxObject **arguments, size_t argCount)
Definition: ObjectClass.cpp:1786
ProtectedObject
Definition: ProtectedObject.hpp:46
RexxInternalObject::setObjectMark
void setObjectMark(size_t markword)
Definition: ObjectClass.hpp:248
ObjectHeader::requiresProxyObject
bool requiresProxyObject()
Definition: ObjectClass.hpp:101
RexxObject::unknown
virtual RexxObject * unknown(RexxString *msg, RexxArray *args)
Definition: ObjectClass.hpp:372
RexxVirtualBase::unflatten
virtual RexxObject * unflatten(RexxEnvelope *)
Definition: ObjectClass.hpp:177
RexxInternalObject::getObjectDataSize
size_t getObjectDataSize()
Definition: ObjectClass.hpp:228
RexxInternalObject::isOldSpace
bool isOldSpace()
Definition: ObjectClass.hpp:252
RexxNilObject::nilObject
static RexxObject * nilObject
Definition: ObjectClass.hpp:563
RexxNilObject::RexxNilObject
RexxNilObject(RESTORETYPE restoreType)
Definition: ObjectClass.hpp:558
RexxInternalObject::isNonPrimitive
bool isNonPrimitive()
Definition: ObjectClass.hpp:246
PCPPM
RexxObject *(RexxObject::* PCPPM)()
Definition: ObjectClass.hpp:198
RexxObject::instanceMethodRexx
RexxMethod * instanceMethodRexx(RexxString *)
Definition: ObjectClass.cpp:327
RexxObject::equal
RexxObject * equal(RexxObject *)
Definition: ObjectClass.cpp:400
GuardLock
Definition: ObjectClass.hpp:611
RexxMessage
Definition: MessageClass.hpp:54
RexxInternalObject::isObjectMarked
bool isObjectMarked(size_t markword)
Definition: ObjectClass.hpp:247
METHODUNFLATTEN
Definition: ObjectClass.hpp:80
Numerics::DEFAULT_DIGITS
static const size_t DEFAULT_DIGITS
Definition: Numerics.hpp:66
GuardLock::GuardLock
GuardLock(RexxActivity *a, RexxObject *o, RexxObject *s)
Definition: ObjectClass.hpp:614
RexxObject::classObject
RexxClass * classObject()
Definition: ObjectClass.cpp:1567
ObjectHeader::setHasNoReferences
void setHasNoReferences()
Definition: ObjectClass.hpp:115
ObjectHeader::ProxyObject
Definition: ObjectClass.hpp:140
ObjectHeader::sizePadding
size_t sizePadding
Definition: ObjectClass.hpp:150
RexxInternalObject::getHashValue
virtual HashCode getHashValue()
Definition: ObjectClass.hpp:276
RexxObject::defMethod
virtual RexxObject * defMethod(RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
Definition: ObjectClass.cpp:2004
GuardLock::scope
RexxObject * scope
Definition: ObjectClass.hpp:628
RexxInternalObject::copyIntoTail
virtual void copyIntoTail(RexxCompoundTail *buffer)
Definition: ObjectClass.cpp:1054
SecurityManager
Definition: SecurityManager.hpp:52
RexxObject::logicalValue
virtual bool logicalValue(logical_t &)
Definition: ObjectClass.cpp:451
ObjectHeader::MarkBit1
Definition: ObjectClass.hpp:137
GuardLock::target
RexxObject * target
Definition: ObjectClass.hpp:627
RexxNilObject::getHashValue
virtual HashCode getHashValue()
Definition: ObjectClass.cpp:2542
BaseExecutable
Definition: MethodClass.hpp:82
RexxObject::numberValue
virtual bool numberValue(wholenumber_t &result, size_t precision)
Definition: ObjectClass.cpp:963
RexxActivation
Definition: RexxActivation.hpp:156
RexxInternalObject::truthValue
virtual bool truthValue(int)
Definition: ObjectClass.cpp:457
RexxInternalObject::setHasNoReferences
void setHasNoReferences()
Definition: ObjectClass.hpp:240
RexxNumberString
Definition: NumberStringClass.hpp:93
RexxObject::hasMethod
virtual RexxInteger * hasMethod(RexxString *msg)
Definition: ObjectClass.cpp:1558
RexxObject::makeStringRexx
RexxObject * makeStringRexx()
Definition: ObjectClass.cpp:2469
RexxObject::makeArray
RexxArray * makeArray()
Definition: ObjectClass.cpp:1111
RexxInternalObject::unsignedNumberValue
virtual bool unsignedNumberValue(stringsize_t &result, size_t precision)
Definition: ObjectClass.cpp:906
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
RexxObject::~RexxObject
virtual ~RexxObject()
Definition: ObjectClass.hpp:368
RexxActivationBase::trap
virtual bool trap(RexxString *, RexxDirectory *)
Definition: ObjectClass.hpp:588
RexxObject::setMdict
RexxObject * setMdict(RexxObject *)
RexxObject::instanceMethod
RexxMethod * instanceMethod(RexxString *)
Definition: ObjectClass.cpp:269
PCPPM5
RexxObject *(RexxObject::* PCPPM5)(RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: ObjectClass.hpp:191
RexxActivationBase::dispatch
virtual RexxObject * dispatch()
Definition: ObjectClass.hpp:578
PCPPM6
RexxObject *(RexxObject::* PCPPM6)(RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: ObjectClass.hpp:192
RexxInternalObject::setObjectLive
void setObjectLive(size_t markword)
Definition: ObjectClass.hpp:238
PCPPMC1
RexxObject *(RexxObject::* PCPPMC1)(RexxObject **, size_t)
Definition: ObjectClass.hpp:195
ObjectHeader::setNewSpace
void setNewSpace()
Definition: ObjectClass.hpp:112
ObjectHeader::setHasReferences
void setHasReferences()
Definition: ObjectClass.hpp:116
RexxInternalObject::makeString
virtual RexxString * makeString()
Definition: ObjectClass.cpp:1045
RexxInternalObject::getValue
virtual RexxObject * getValue(RexxActivation *)
Definition: ObjectClass.hpp:270
stringsize_t
size_t stringsize_t
Definition: rexx.h:228
RexxObject::sendWith
RexxObject * sendWith(RexxObject *, RexxArray *)
Definition: ObjectClass.cpp:1672
RexxObject::requiredString
RexxString * requiredString()
Definition: ObjectClass.cpp:1280
RexxObject::hasMethodRexx
RexxObject * hasMethodRexx(RexxString *)
Definition: ObjectClass.cpp:2512
RexxObject::newObject
RexxObject * newObject()
Definition: ObjectClass.hpp:324
RexxInternalObject::isPrimitive
bool isPrimitive()
Definition: ObjectClass.hpp:245
ObjectHeader
Definition: ObjectClass.hpp:83
RexxObject::setMethod
RexxObject * setMethod(RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
Definition: ObjectClass.cpp:1576
Numerics::DEFAULT_FUZZ
static const size_t DEFAULT_FUZZ
Definition: Numerics.hpp:79
RexxObject::unsignedNumberValue
virtual bool unsignedNumberValue(stringsize_t &result, size_t precision)
Definition: ObjectClass.cpp:981
RexxObject::mdict
RexxObject * mdict()
ObjectHeader::initHeader
void initHeader(size_t l, size_t mark)
Definition: ObjectClass.hpp:123
RexxInternalObject::setInitHeader
void setInitHeader(size_t markword)
Definition: ObjectClass.hpp:236
RexxVirtualBase::live
virtual void live(size_t)
Definition: ObjectClass.hpp:174
RexxObject::start
RexxMessage * start(RexxObject **, size_t)
Definition: ObjectClass.cpp:1761
RexxInternalObject::hasReferences
bool hasReferences()
Definition: ObjectClass.hpp:241
RexxObject::setObjectVariable
void setObjectVariable(RexxString *, RexxObject *, RexxObject *)
Definition: ObjectClass.cpp:2121
RexxNilObject::hashValue
HashCode hashValue
Definition: ObjectClass.hpp:568
RexxInternalObject::clearObjectMark
void clearObjectMark()
Definition: ObjectClass.hpp:249
RexxObject::numberString
RexxNumberString * numberString()
Definition: ObjectClass.cpp:1018
RexxInternalObject::primitiveMakeString
virtual RexxString * primitiveMakeString()
Definition: ObjectClass.cpp:1062
ObjectHeader::initHeader
void initHeader(size_t mark)
Definition: ObjectClass.hpp:128
RexxObject::addObjectVariables
void addObjectVariables(RexxVariableDictionary *)
Definition: ObjectClass.cpp:2139
RexxActivationBase::termination
virtual void termination()
Definition: ObjectClass.hpp:590
RexxObject::isEqual
bool isEqual(RexxObject *)
Definition: ObjectClass.cpp:131
RexxObject::defaultNameRexx
RexxString * defaultNameRexx()
Definition: ObjectClass.cpp:2485
RexxActivationBase::digits
virtual size_t digits()
Definition: ObjectClass.hpp:579
RexxObject::copyObjectVariables
void copyObjectVariables(RexxObject *newObject)
Definition: ObjectClass.cpp:542
RexxActivationBase::getExecutableObject
RexxObject * getExecutableObject()
Definition: ObjectClass.hpp:599
RexxObject::requestInteger
RexxInteger * requestInteger(size_t)
Definition: ObjectClass.cpp:1295
RexxObject::requestArray
RexxArray * requestArray()
Definition: ObjectClass.cpp:1461
RexxObject::run
RexxObject * run(RexxObject **, size_t)
Definition: ObjectClass.cpp:1883
PCPPMA1
RexxObject *(RexxObject::* PCPPMA1)(RexxArray *)
Definition: ObjectClass.hpp:194
RexxObject::liveGeneral
void liveGeneral(int reason)
Definition: ObjectClass.cpp:86
RexxActivationBase::getPreviousStackFrame
RexxActivationBase * getPreviousStackFrame()
Definition: ObjectClass.hpp:597
RexxObject::oref
RexxString * oref()
Definition: ObjectClass.cpp:1861
RexxObject::identityHashRexx
RexxInteger * identityHashRexx()
Definition: ObjectClass.cpp:2273
RexxActivationBase::findRexxContext
virtual RexxActivation * findRexxContext()
Definition: ObjectClass.hpp:584
RexxActivationBase::getReceiver
virtual RexxObject * getReceiver()
Definition: ObjectClass.hpp:595
RexxObject::processProtectedMethod
void processProtectedMethod(RexxString *, RexxMethod *, RexxObject **, size_t, ProtectedObject &)
Definition: ObjectClass.cpp:840
RexxObject::requestStringNoNOSTRING
RexxString * requestStringNoNOSTRING()
Definition: ObjectClass.cpp:1186
ObjectHeader::isObjectDead
bool isObjectDead(size_t mark)
Definition: ObjectClass.hpp:108
RexxActivationBase::form
virtual bool form()
Definition: ObjectClass.hpp:581
RESTORETYPE
RESTORETYPE
Definition: ObjectClass.hpp:80
RexxList
Definition: ListClass.hpp:63
RexxInternalObject::isBaseClass
bool isBaseClass()
Definition: ObjectClass.cpp:172
ObjectHeader::operator=
ObjectHeader & operator=(ObjectHeader &h)
Definition: ObjectClass.hpp:86
RexxObject::sendMessage
void sendMessage(RexxString *message, RexxObject **args, size_t argCount, ProtectedObject &result)
Definition: ObjectClass.hpp:441
RexxObject::requiredPositive
stringsize_t requiredPositive(size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
Definition: ObjectClass.cpp:1423
RexxObject::superScope
RexxObject * superScope(RexxObject *)
Definition: ObjectClass.cpp:2151
RexxObject::sendMessage
void sendMessage(RexxString *message, ProtectedObject &result)
Definition: ObjectClass.hpp:440
RexxCompoundTail
Definition: RexxCompoundTail.hpp:52
RexxMethod
Definition: MethodClass.hpp:101
RexxActivationBase::setFuzz
virtual void setFuzz(size_t)
Definition: ObjectClass.hpp:586
RexxInternalObject::getValue
virtual RexxObject * getValue(RexxVariableDictionary *)
Definition: ObjectClass.hpp:271
RexxObject::stringValue
RexxString * stringValue()
Definition: ObjectClass.cpp:1036
RexxObject::instanceMethodsRexx
RexxSupplier * instanceMethodsRexx(RexxClass *)
Definition: ObjectClass.cpp:344
RexxInternalObject::stringValue
virtual RexxString * stringValue()
Definition: ObjectClass.cpp:1028
GuardLock::activity
RexxActivity * activity
Definition: ObjectClass.hpp:626
RexxInteger
Definition: IntegerClass.hpp:56
RexxObject::instanceMethods
RexxSupplier * instanceMethods(RexxClass *)
Definition: ObjectClass.cpp:312
RexxActivationBase::setObjNotify
virtual void setObjNotify(RexxMessage *)
Definition: ObjectClass.hpp:589
RexxObject::live
void live(size_t)
Definition: ObjectClass.cpp:78
RexxObject::requestString
RexxString * requestString()
Definition: ObjectClass.cpp:1124
RexxInternalObject::setInitHeader
void setInitHeader(size_t s, size_t markword)
Definition: ObjectClass.hpp:235
RexxInternalObject::printObject
void printObject()
Definition: ObjectClass.cpp:2522
RexxVirtualBase::baseVirtual
virtual void baseVirtual()
Definition: ObjectClass.hpp:166
RexxActivationBase::isStackBase
virtual bool isStackBase()
Definition: ObjectClass.hpp:593
RexxObject::isInstanceOfRexx
RexxObject * isInstanceOfRexx(RexxClass *)
Definition: ObjectClass.cpp:240
PCPPM2
RexxObject *(RexxObject::* PCPPM2)(RexxObject *, RexxObject *)
Definition: ObjectClass.hpp:188
RexxObject::classInstance
static RexxClass * classInstance
Definition: ObjectClass.hpp:545
RexxInternalObject::isObjectLive
bool isObjectLive(size_t mark)
Definition: ObjectClass.hpp:250
RexxInternalObject::header
ObjectHeader header
Definition: ObjectClass.hpp:305
RexxObject
Definition: ObjectClass.hpp:311
RexxObject::unsetMethod
RexxObject * unsetMethod(RexxString *)
Definition: ObjectClass.cpp:1618
RexxString
Definition: StringClass.hpp:119
RexxObject::RexxObject
RexxObject()
Definition: ObjectClass.hpp:327
ObjectHeader::IsNonPrimitive
Definition: ObjectClass.hpp:141
PCPPM7
RexxObject *(RexxObject::* PCPPM7)(RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: ObjectClass.hpp:193
RexxObject::hashCode
RexxObject * hashCode()
Definition: ObjectClass.cpp:355