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)  
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
RexxMemory Class Reference

#include <RexxMemory.hpp>

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

Public Member Functions

 RexxMemory ()
 
 RexxMemory (RESTORETYPE restoreType)
 
 operator RexxObject * ()
 
RexxObject * operator= (DeadObject *d)
 
void live (size_t)
 
void liveGeneral (int reason)
 
void flatten (RexxEnvelope *)
 
RexxObject * makeProxy (RexxEnvelope *)
 
void initialize (bool restoringImage)
 
MemorySegment * newSegment (size_t requestLength, size_t minLength)
 
MemorySegment * newLargeSegment (size_t requestLength, size_t minLength)
 
RexxObject * oldObject (size_t size)
 
RexxObject * newObject (size_t size)
 
RexxObject * newObject (size_t size, size_t type)
 
RexxObject * temporaryObject (size_t size)
 
RexxArray * newObjects (size_t size, size_t count, size_t objectType)
 
void reSize (RexxObject *, size_t)
 
void checkUninit ()
 
void runUninits ()
 
void removeUninitObject (RexxObject *obj)
 
void addUninitObject (RexxObject *obj)
 
bool isPendingUninit (RexxObject *obj)
 
void checkUninitQueue ()
 
void markObjects (void)
 
void markObjectsMain (RexxObject *)
 
void killOrphans (RexxObject *)
 
void mark (RexxObject *)
 
void markGeneral (void *)
 
void collect ()
 
RexxObject * saveObject (RexxInternalObject *saveObj)
 
void discardObject (RexxInternalObject *obj)
 
void removeHold (RexxInternalObject *obj)
 
void discardHoldObject (RexxInternalObject *obj)
 
RexxObject * holdObject (RexxInternalObject *obj)
 
void saveImage ()
 
bool savingImage ()
 
bool restoringImage ()
 
RexxObject * setDump (RexxObject *)
 
bool queryDump ()
 
RexxObject * dump ()
 
void dumpObject (RexxObject *objectRef, FILE *outfile)
 
void setObjectOffset (size_t offset)
 
void setEnvelope (RexxEnvelope *)
 
void setMarkTable (RexxTable *marktable)
 
void setOrphanCheck (bool orphancheck)
 
RexxObject * checkSetOref (RexxObject *, RexxObject **, RexxObject *, const char *, int)
 
RexxObject * setOref (void *index, RexxObject *value)
 
RexxStack * getFlattenStack ()
 
void returnFlattenStack ()
 
RexxObject * reclaim ()
 
RexxObject * setParms (RexxObject *, RexxObject *)
 
RexxObject * gutCheck ()
 
void memoryPoolAdded (MemorySegmentPool *)
 
void shutdown ()
 
void liveStackFull ()
 
void dumpMemoryProfile ()
 
char * allocateImageBuffer (size_t size)
 
void logVerboseOutput (const char *message, void *sub1, void *sub2)
 
void verboseMessage (const char *message)
 
void verboseMessage (const char *message, size_t sub1)
 
void verboseMessage (const char *message, size_t sub1, size_t sub2)
 
void logObjectStats (RexxObject *obj)
 
void pushSaveStack (RexxObject *obj)
 
void removeSavedObject (RexxObject *obj)
 
void disableOrefChecks ()
 
void enableOrefChecks ()
 
void clearSaveStack ()
 
void checkAllocs ()
 
RexxObject * dumpImageStats ()
 
void scavengeSegmentSets (MemorySegmentSet *requester, size_t allocationLength)
 
void setUpMemoryTables (RexxIdentityTable *old2newTable)
 
void collectAndUninit (bool clearStack)
 
void lastChanceUninit ()
 
RexxDirectory * getGlobalStrings ()
 
void addWeakReference (WeakReference *ref)
 
void checkWeakReferences ()
 
- Public Member Functions inherited from RexxInternalObject
void * operator new (size_t, RexxClass *)
 
void * operator new (size_t, RexxClass *, RexxObject **, size_t)
 
void * operator new (size_t size, void *ptr)
 
void operator delete (void *)
 
void operator delete (void *p, void *ptr)
 
 RexxInternalObject ()
 
 RexxInternalObject (RESTORETYPE restoreType)
 
virtual ~RexxInternalObject ()
 
 operator RexxObject * ()
 
size_t getObjectSize ()
 
void setObjectSize (size_t s)
 
size_t getObjectDataSize ()
 
void * getObjectDataSpace ()
 
void clearObject ()
 
void clearObject (size_t l)
 
void setVirtualFunctions (void *t)
 
void setInitHeader (size_t s, size_t markword)
 
void setInitHeader (size_t markword)
 
void setObjectLive (size_t markword)
 
void setHasReferences ()
 
void setHasNoReferences ()
 
bool hasReferences ()
 
bool hasNoReferences ()
 
void setPrimitive ()
 
void setNonPrimitive ()
 
bool isPrimitive ()
 
bool isNonPrimitive ()
 
bool isObjectMarked (size_t markword)
 
void setObjectMark (size_t markword)
 
void clearObjectMark ()
 
bool isObjectLive (size_t mark)
 
bool isObjectDead (size_t mark)
 
bool isOldSpace ()
 
bool isNewSpace ()
 
void setNewSpace ()
 
void setOldSpace ()
 
void makeProxiedObject ()
 
bool isProxyObject ()
 
bool isSubClassOrEnhanced ()
 
bool isBaseClass ()
 
size_t getObjectTypeNumber ()
 
RexxBehaviour * getObjectType ()
 
bool isObjectType (RexxBehaviour *b)
 
bool isObjectType (size_t t)
 
bool isSameType (RexxInternalObject *o)
 
void setBehaviour (RexxBehaviour *b)
 
virtual RexxObject * copy ()
 
virtual RexxObject * evaluate (RexxActivation *, RexxExpressionStack *)
 
virtual RexxObject * getValue (RexxActivation *)
 
virtual RexxObject * getValue (RexxVariableDictionary *)
 
virtual RexxObject * getRealValue (RexxActivation *)
 
virtual RexxObject * getRealValue (RexxVariableDictionary *)
 
virtual void uninit ()
 
virtual HashCode hash ()
 
virtual HashCode getHashValue ()
 
HashCode identityHash ()
 
virtual bool truthValue (int)
 
virtual bool logicalValue (logical_t &)
 
virtual RexxString * makeString ()
 
virtual void copyIntoTail (RexxCompoundTail *buffer)
 
virtual RexxString * primitiveMakeString ()
 
virtual RexxArray * makeArray ()
 
virtual RexxString * stringValue ()
 
virtual RexxInteger * integerValue (size_t)
 
virtual bool numberValue (wholenumber_t &result, size_t precision)
 
virtual bool numberValue (wholenumber_t &result)
 
virtual bool unsignedNumberValue (stringsize_t &result, size_t precision)
 
virtual bool unsignedNumberValue (stringsize_t &result)
 
virtual bool doubleValue (double &result)
 
virtual RexxNumberString * numberString ()
 
virtual bool isEqual (RexxObject *)
 
virtual bool isInstanceOf (RexxClass *)
 
virtual RexxMethod * instanceMethod (RexxString *)
 
virtual RexxSupplier * instanceMethods (RexxClass *)
 
void hasUninit ()
 
void removedUninit ()
 
void printObject ()
 
RexxObject * clone ()
 
- Public Member Functions inherited from RexxVirtualBase
virtual RexxObject * unflatten (RexxEnvelope *)
 

Static Public Member Functions

static void createLocks ()
 
static void closeLocks ()
 
static void restore ()
 
static void buildVirtualFunctionTable ()
 
static void create ()
 
static void createImage ()
 
static RexxString * getGlobalName (const char *value)
 
static void createStrings ()
 
static RexxArray * saveStrings ()
 
static void restoreStrings (RexxArray *stringArray)
 
- Static Public Member Functions inherited from RexxInternalObject
static size_t getObjectHeaderSize ()
 

Public Attributes

size_t markWord
 
int markReason
 
RexxVariable * variableCache
 
GlobalProtectedObject * protectedObjects
 
- Public Attributes inherited from RexxInternalObject
ObjectHeader header
 
RexxBehaviour * behaviour
 

Static Public Attributes

static void * virtualFunctionTable [] = {NULL}
 
static PCPPM exportedMethods []
 
static RexxDirectory * environment = OREF_NULL
 
static RexxDirectory * functionsDir = OREF_NULL
 
static RexxDirectory * commonRetrievers = OREF_NULL
 
static RexxDirectory * kernel = OREF_NULL
 
static RexxDirectory * system = OREF_NULL
 

Private Types

enum  {
  saveArray_ENV = 1, saveArray_KERNEL, saveArray_NAME_STRINGS, saveArray_TRUE,
  saveArray_FALSE, saveArray_NIL, saveArray_GLOBAL_STRINGS, saveArray_CLASS,
  saveArray_PBEHAV, saveArray_PACKAGES, saveArray_NULLA, saveArray_NULLPOINTER,
  saveArray_SYSTEM, saveArray_FUNCTIONS, saveArray_COMMON_RETRIEVERS, saveArray_highest = saveArray_COMMON_RETRIEVERS
}
 

Private Member Functions

void checkLiveStack ()
 
void pushLiveStack (RexxObject *obj)
 
RexxObject * popLiveStack ()
 
void bumpMarkWord ()
 
void restoreMark (RexxObject *markObject, RexxObject **pMarkObject)
 
void unflattenMark (RexxObject *markObject, RexxObject **pMarkObject)
 
void restoreObjectMark (RexxObject *markObject, RexxObject **pMarkObject)
 
void saveImageMark (RexxObject *markObject, RexxObject **pMarkObject)
 
void orphanCheckMark (RexxObject *markObject, RexxObject **pMarkObject)
 
bool inObjectStorage (RexxObject *obj)
 
bool inSharedObjectStorage (RexxObject *obj)
 
bool objectReferenceOK (RexxObject *o)
 
void restoreImage ()
 

Static Private Member Functions

static void defineKernelMethod (const char *name, RexxBehaviour *behaviour, PCPPM entryPoint, size_t arguments)
 
static void defineProtectedKernelMethod (const char *name, RexxBehaviour *behaviour, PCPPM entryPoint, size_t arguments)
 
static void definePrivateKernelMethod (const char *name, RexxBehaviour *behaviour, PCPPM entryPoint, size_t arguments)
 

Private Attributes

RexxStack * liveStack
 
RexxStack * flattenStack
 
RexxSaveStack * saveStack
 
RexxIdentityTable * saveTable
 
RexxTable * markTable
 
RexxIdentityTable * old2new
 
RexxIdentityTable * uninitTable
 
size_t pendingUninits
 
bool processingUninits
 
MemorySegmentPool * firstPool
 
MemorySegmentPool * currentPool
 
OldSpaceSegmentSet oldSpaceSegments
 
NormalSegmentSet newSpaceNormalSegments
 
LargeSegmentSet newSpaceLargeSegments
 
char * image_buffer
 
size_t image_offset
 
size_t relocation
 
bool dumpEnable
 
bool saveimage
 
bool restoreimage
 
bool checkSetOK
 
bool orphanCheck
 
size_t objOffset
 
RexxEnvelope * envelope
 
RexxStack * originalLiveStack
 
MemoryStats * imageStats
 
size_t allocations
 
size_t collections
 
WeakReference * weakReferenceList
 

Static Private Attributes

static RexxDirectory * globalStrings = OREF_NULL
 
static SysMutex flattenMutex
 
static SysMutex unflattenMutex
 
static SysMutex envelopeMutex
 

Additional Inherited Members

- Protected Member Functions inherited from RexxVirtualBase
virtual ~RexxVirtualBase ()
 
virtual void baseVirtual ()
 

Detailed Description

Definition at line 169 of file RexxMemory.hpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
private
Enumerator
saveArray_ENV 
saveArray_KERNEL 
saveArray_NAME_STRINGS 
saveArray_TRUE 
saveArray_FALSE 
saveArray_NIL 
saveArray_GLOBAL_STRINGS 
saveArray_CLASS 
saveArray_PBEHAV 
saveArray_PACKAGES 
saveArray_NULLA 
saveArray_NULLPOINTER 
saveArray_SYSTEM 
saveArray_FUNCTIONS 
saveArray_COMMON_RETRIEVERS 
saveArray_highest 

Definition at line 310 of file RexxMemory.hpp.

Constructor & Destructor Documentation

◆ RexxMemory() [1/2]

RexxMemory::RexxMemory ( )
inline

Definition at line 117 of file RexxMemory.cpp.

References currentPool, dumpEnable, envelope, firstPool, markWord, objOffset, OREF_NULL, orphanCheck, roundObjectBoundary(), saveStack, saveTable, RexxInternalObject::setObjectSize(), and weakReferenceList.

◆ RexxMemory() [2/2]

RexxMemory::RexxMemory ( RESTORETYPE  restoreType)
inline

Definition at line 176 of file RexxMemory.hpp.

Member Function Documentation

◆ addUninitObject()

void RexxMemory::addUninitObject ( RexxObject *  obj)

Definition at line 589 of file RexxMemory.cpp.

References RexxIdentityTable::get(), OREF_NULL, RexxIdentityTable::put(), TheNilObject, and uninitTable.

Referenced by RexxInternalObject::hasUninit().

◆ addWeakReference()

void RexxMemory::addWeakReference ( WeakReference *  ref)

Definition at line 702 of file RexxMemory.cpp.

References WeakReference::nextReferenceList, and weakReferenceList.

Referenced by WeakReference::unflatten(), and WeakReference::WeakReference().

◆ allocateImageBuffer()

char * RexxMemory::allocateImageBuffer ( size_t  size)

Definition at line 1060 of file RexxMemory.cpp.

References oldObject().

Referenced by SystemInterpreter::loadImage().

◆ buildVirtualFunctionTable()

void RexxMemory::buildVirtualFunctionTable ( )
static

Definition at line 169 of file VirtualFunctionTable.cpp.

References getVftPointer(), RESTOREIMAGE, T_AbstractCode, T_Activation, T_ActivationFrameBuffer, T_Activity, T_AddressInstruction, T_Array, T_ArrayClass, T_AssignmentInstruction, T_AttributeGetterCode, T_AttributeSetterCode, T_Behaviour, T_BinaryOperatorTerm, T_Buffer, T_BufferClass, T_CallInstruction, T_Class, T_ClassClass, T_ClassDirective, T_Clause, T_CommandHandler, T_CommandInstruction, T_CompoundElement, T_CompoundVariableTerm, T_ConstantGetterCode, T_CPPCode, T_Directory, T_DirectoryClass, T_DoBlock, T_DoInstruction, T_DotVariableTerm, T_DropInstruction, T_ElseInstruction, T_EndIfInstruction, T_EndInstruction, T_Envelope, T_ExitInstruction, T_ExposeInstruction, T_ForwardInstruction, T_FunctionCallTerm, T_GuardInstruction, T_HashTable, T_IdentityTable, T_IdentityTableClass, T_IfInstruction, T_IndirectVariableTerm, T_Instruction, T_Integer, T_IntegerClass, T_InternalStack, T_InterpreterInstance, T_InterpretInstruction, T_LabelInstruction, T_LeaveInstruction, T_LibraryDirective, T_LibraryPackage, T_List, T_ListClass, T_ListTable, T_LogicalTerm, T_Memory, T_Message, T_MessageClass, T_MessageInstruction, T_MessageSendTerm, T_Method, T_MethodClass, T_MutableBuffer, T_MutableBufferClass, T_NativeActivation, T_NativeMethod, T_NativeRoutine, T_NilObject, T_NopInstruction, T_NumberString, T_NumberStringClass, T_NumericInstruction, T_Object, T_ObjectClass, T_OptionsInstruction, T_OtherwiseInstruction, T_Package, T_PackageClass, T_ParseInstruction, T_ParseTrigger, T_Pointer, T_PointerClass, T_ProcedureInstruction, T_Queue, T_QueueClass, T_QueueInstruction, T_RaiseInstruction, T_RegisteredRoutine, T_Relation, T_RelationClass, T_ReplyInstruction, T_RequiresDirective, T_ReturnInstruction, T_RexxCode, T_RexxContext, T_RexxContextClass, T_RexxSource, T_Routine, T_RoutineClass, T_SayInstruction, T_SecurityManager, T_SelectInstruction, T_SignalInstruction, T_SmartBuffer, T_Stack, T_StackFrame, T_StackFrameClass, T_Stem, T_StemClass, T_StemVariableTerm, T_String, T_StringClass, T_Supplier, T_SupplierClass, T_Table, T_TableClass, T_ThenInstruction, T_Token, T_TraceInstruction, T_UnaryOperatorTerm, T_UseInstruction, T_Variable, T_VariableDictionary, T_VariableTerm, T_WeakReference, T_WeakReferenceClass, and virtualFunctionTable.

Referenced by initialize().

◆ bumpMarkWord()

void RexxMemory::bumpMarkWord ( )
inlineprivate

Definition at line 334 of file RexxMemory.hpp.

References MarkMask, and markWord.

Referenced by collect(), and saveImage().

◆ checkAllocs()

void RexxMemory::checkAllocs ( )

◆ checkLiveStack()

void RexxMemory::checkLiveStack ( )
inlineprivate

Definition at line 331 of file RexxMemory.hpp.

References RexxStack::checkRoom(), liveStack, and liveStackFull().

Referenced by pushLiveStack().

◆ checkSetOref()

RexxObject * RexxMemory::checkSetOref ( RexxObject *  setter,
RexxObject **  index,
RexxObject *  value,
const char *  fileName,
int  lineNum 
)

Definition at line 2066 of file RexxMemory.cpp.

References checkSetOK, dumpObject(), RexxInternalObject::getObjectSize(), RexxBehaviour::getPrimitiveBehaviour(), SysFileSystem::getTempFileName(), inObjectStorage(), RexxInternalObject::isOldSpace(), Interpreter::logicError(), logMemoryCheck(), objectReferenceOK(), setOref(), T_Behaviour, and TheBehaviourBehaviour.

◆ checkUninit()

void RexxMemory::checkUninit ( )

Definition at line 441 of file RexxMemory.cpp.

References RexxHashTableCollection::first(), RexxHashTableCollection::index(), RexxInternalObject::isObjectDead(), markWord, RexxHashTableCollection::next(), OREF_NULL, pendingUninits, RexxTable::replace(), TheTrueObject, and uninitTable.

Referenced by markObjects().

◆ checkUninitQueue()

void RexxMemory::checkUninitQueue ( )
inline

Definition at line 200 of file RexxMemory.hpp.

References pendingUninits, and runUninits().

Referenced by RexxActivation::run().

◆ checkWeakReferences()

void RexxMemory::checkWeakReferences ( )

Definition at line 666 of file RexxMemory.cpp.

References RexxInternalObject::isObjectLive(), markWord, WeakReference::nextReferenceList, OREF_NULL, WeakReference::referentObject, and weakReferenceList.

Referenced by markObjects().

◆ clearSaveStack()

void RexxMemory::clearSaveStack ( )
inline

Definition at line 260 of file RexxMemory.hpp.

References saveStack, RexxStack::size, and RexxStack::stack.

Referenced by collectAndUninit().

◆ closeLocks()

void RexxMemory::closeLocks ( )
static

Definition at line 2256 of file RexxMemory.cpp.

References SysMutex::close(), envelopeMutex, flattenMutex, and unflattenMutex.

Referenced by Interpreter::processShutdown().

◆ collect()

void RexxMemory::collect ( )

Definition at line 1001 of file RexxMemory.cpp.

References allocations, bumpMarkWord(), collections, RexxHashTableCollection::items(), markObjects(), newSpaceLargeSegments, newSpaceNormalSegments, saveTable, MemorySegmentSet::sweep(), and verboseMessage().

Referenced by collectAndUninit(), LargeSegmentSet::expandOrCollect(), NormalSegmentSet::handleAllocationFailure(), and reclaim().

◆ collectAndUninit()

void RexxMemory::collectAndUninit ( bool  clearStack)

Force a last-gasp garbage collection and running of the uninits during interpreter instance shutdown. This is an attempt to ensure that all objects with uninit methods get a chance to clean up prior to termination.

Definition at line 479 of file RexxMemory.cpp.

References clearSaveStack(), collect(), and runUninits().

Referenced by lastChanceUninit(), and InterpreterInstance::terminate().

◆ create()

void RexxMemory::create ( )
static

Definition at line 2300 of file RexxMemory.cpp.

References RexxClass::createInstance(), RexxInteger::createInstance(), createLocks(), memoryObject, OREF_NULL, and setUpMemoryTables().

Referenced by createImage().

◆ createImage()

void RexxMemory::createImage ( )
static

Definition at line 132 of file Setup.cpp.

References A_COUNT, RexxString::abbrev(), RexxInteger::abs(), RexxString::abs(), RexxNumberString::abs(), PackageClass::addClass(), PackageClass::addPackage(), PackageClass::addPublicClass(), PackageClass::addPublicRoutine(), PackageClass::addRoutine(), RexxHashTableCollection::allAt(), RexxRelation::allIndex(), RexxQueue::allIndexes(), RexxList::allIndexes(), RexxDirectory::allIndexes(), RexxHashTableCollection::allIndexes(), RexxStem::allIndexes(), RexxArray::allIndexes(), RexxList::allItems(), RexxDirectory::allItems(), RexxHashTableCollection::allItems(), RexxStem::allItems(), RexxArray::allItems(), RexxInteger::andOp(), RexxString::andOp(), RexxNumberString::andOp(), RexxQueue::append(), RexxMutableBuffer::append(), RexxList::append(), RexxArray::appendRexx(), RexxMessage::arguments(), RexxQueue::at(), RexxDirectory::atRexx(), RexxSupplier::available(), RexxString::b2x(), BASEIMAGELOAD, RexxString::bitAnd(), RexxString::bitOr(), RexxString::bitXor(), RexxStem::bracket(), RexxStem::bracketEqual(), RexxString::c2d(), RexxString::c2x(), RoutineClass::callRexx(), RoutineClass::callWithRexx(), RexxString::caselessAbbrev(), RexxMutableBuffer::caselessChangeStr(), RexxString::caselessChangeStr(), RexxString::caselessCompare(), RexxString::caselessCompareToRexx(), RexxMutableBuffer::caselessCountStrRexx(), RexxString::caselessCountStrRexx(), RexxString::caselessEquals(), RexxMutableBuffer::caselessLastPos(), RexxString::caselessLastPosRexx(), RexxMutableBuffer::caselessMatch(), RexxString::caselessMatch(), RexxMutableBuffer::caselessMatchChar(), RexxString::caselessMatchChar(), RexxMutableBuffer::caselessPos(), RexxString::caselessPosRexx(), RexxMutableBuffer::caselessWordPos(), RexxString::caselessWordPos(), RexxInteger::ceiling(), RexxNumberString::ceiling(), RexxString::ceiling(), RexxString::center(), RexxMutableBuffer::changeStr(), RexxString::changeStr(), CHAR_ABBREV, CHAR_ABS, CHAR_ACTIVATE, CHAR_ADDCLASS, CHAR_ADDPACKAGE, CHAR_ADDPUBLICCLASS, CHAR_ADDPUBLICROUTINE, CHAR_ADDROUTINE, CHAR_ALLAT, CHAR_ALLINDEX, CHAR_ALLINDEXES, CHAR_ALLITEMS, CHAR_AND, CHAR_APPEND, CHAR_ARGS, CHAR_ARGUMENTS, CHAR_ARRAY, CHAR_AT, CHAR_AVAILABLE, CHAR_B2X, CHAR_BACKSLASH, CHAR_BACKSLASH_EQUAL, CHAR_BACKSLASH_GREATERTHAN, CHAR_BACKSLASH_LESSTHAN, CHAR_BASECLASS, CHAR_BITAND, CHAR_BITOR, CHAR_BITXOR, CHAR_BLANK, CHAR_BRACKETS, CHAR_BRACKETSEQUAL, CHAR_BUFFER, CHAR_C2D, CHAR_C2X, CHAR_CALL, CHAR_CALLWITH, CHAR_CASELESSABBREV, CHAR_CASELESSCHANGESTR, CHAR_CASELESSCOMPARE, CHAR_CASELESSCOMPARETO, CHAR_CASELESSCOUNTSTR, CHAR_CASELESSEQUALS, CHAR_CASELESSLASTPOS, CHAR_CASELESSMATCH, CHAR_CASELESSMATCHCHAR, CHAR_CASELESSPOS, CHAR_CASELESSWORDPOS, CHAR_CENTER, CHAR_CENTRE, CHAR_CHANGESTR, CHAR_CLASS, CHAR_CLASSES, CHAR_COMMON_RETRIEVERS, CHAR_COMPARABLE, CHAR_COMPARE, CHAR_COMPARETO, CHAR_COMPLETED, CHAR_CONCATENATE, CHAR_CONDITION, CHAR_COPIES, CHAR_COPY, CHAR_COUNTSTR, CHAR_D2C, CHAR_D2X, CHAR_DATATYPE, CHAR_DECODEBASE64, CHAR_DEFAULTNAME, CHAR_DEFINE, CHAR_DEFINE_METHODS, CHAR_DEFINEDMETHODS, CHAR_DELETE, CHAR_DELSTR, CHAR_DELWORD, CHAR_DIGITS, CHAR_DIMENSION, CHAR_DIRECTORY, CHAR_DIVIDE, CHAR_EMPTY, CHAR_ENCODEBASE64, CHAR_ENHANCED, CHAR_ENTRY, CHAR_ENVIRONMENT, CHAR_EQUAL, CHAR_EQUALS, CHAR_ERRORCONDITION, CHAR_EXECUTABLE, CHAR_FALSE, CHAR_FINDCLASS, CHAR_FINDROUTINE, CHAR_FIRST, CHAR_FIRSTITEM, CHAR_FORM, CHAR_FORMAT, CHAR_FUNCTIONS, CHAR_FUZZ, CHAR_GETBUFFERSIZE, CHAR_GREATERTHAN, CHAR_GREATERTHAN_EQUAL, CHAR_GREATERTHAN_LESSTHAN, CHAR_HASENTRY, CHAR_HASERROR, CHAR_HASHCODE, CHAR_HASINDEX, CHAR_HASITEM, CHAR_HASMETHOD, CHAR_ID, CHAR_IDENTITYHASH, CHAR_IDENTITYTABLE, CHAR_IMPORTEDCLASSES, CHAR_IMPORTEDPACKAGES, CHAR_IMPORTEDROUTINES, CHAR_INDEX, CHAR_INHERIT, CHAR_INIT, CHAR_INSERT, CHAR_INSTANCEMETHOD, CHAR_INSTANCEMETHODS, CHAR_INTDIV, CHAR_INTEGER, CHAR_INTERNALNAME, CHAR_ISA, CHAR_ISEMPTY, CHAR_ISGUARDED, CHAR_ISINSTANCEOF, CHAR_ISNULL, CHAR_ISPRIVATE, CHAR_ISPROTECTED, CHAR_ISSUBCLASSOF, CHAR_ITEM, CHAR_ITEMS, CHAR_KERNEL, CHAR_LAST, CHAR_LASTITEM, CHAR_LASTPOS, CHAR_LEFT, CHAR_LENGTH, CHAR_LESSTHAN, CHAR_LESSTHAN_EQUAL, CHAR_LESSTHAN_GREATERTHAN, CHAR_LIST, CHAR_LOADPACKAGE, CHAR_LOCAL, CHAR_LOWER, CHAR_MAKEARRAY, CHAR_MAKESTRING, CHAR_MAPCOLLECTION, CHAR_MATCH, CHAR_MATCHCHAR, CHAR_MESSAGE, CHAR_MESSAGENAME, CHAR_METACLASS, CHAR_METHOD, CHAR_METHODS, CHAR_MIXINCLASS, CHAR_MULTIPLY, CHAR_MUTABLEBUFFER, CHAR_NAME, CHAR_NEW, CHAR_NEWFILE, CHAR_NEXT, CHAR_NIL, CHAR_NOTIFY, CHAR_NULLARRAY, CHAR_NULLPOINTER, CHAR_NULLSTRING, CHAR_NUMBERSTRING, CHAR_OBJECT, CHAR_OBJECTNAME, CHAR_OBJECTNAMEEQUALS, CHAR_OF, CHAR_OR, CHAR_ORDEREDCOLLECTION, CHAR_ORXMAX, CHAR_ORXMIN, CHAR_OVERLAY, CHAR_PACKAGE, CHAR_PEEK, CHAR_PLUS, CHAR_POINTER, CHAR_POS, CHAR_POWER, CHAR_PREVIOUS, CHAR_PUBLICCLASSES, CHAR_PUBLICROUTINES, CHAR_PULL, CHAR_PUSH, CHAR_PUT, CHAR_QUERYMIXINCLASS, CHAR_QUEUE, CHAR_RELATION, CHAR_REMAINDER, CHAR_REMOVE, CHAR_REMOVEITEM, CHAR_REPLACEAT, CHAR_REQUEST, CHAR_RESULT, CHAR_REVERSE, CHAR_REXXCONTEXT, CHAR_RIGHT, CHAR_ROUTINE, CHAR_ROUTINES, CHAR_RUN, CHAR_SECTION, CHAR_SEND, CHAR_SETBUFFERSIZE, CHAR_SETENTRY, CHAR_SETGUARDED, CHAR_SETMETHOD, CHAR_SETPRIVATE, CHAR_SETPROTECTED, CHAR_SETSECURITYMANAGER, CHAR_SETUNGUARDED, CHAR_SHRIEKREXXDEFINED, CHAR_SIGN, CHAR_SIZE, CHAR_SORT, CHAR_SORTWITH, CHAR_SOURCE, CHAR_SOURCELINE, CHAR_SOURCESIZE, CHAR_SPACE, CHAR_STABLESORT, CHAR_STABLESORTWITH, CHAR_START, CHAR_STEM, CHAR_STRICT_BACKSLASH_EQUAL, CHAR_STRICT_BACKSLASH_GREATERTHAN, CHAR_STRICT_BACKSLASH_LESSTHAN, CHAR_STRICT_EQUAL, CHAR_STRICT_GREATERTHAN, CHAR_STRICT_GREATERTHAN_EQUAL, CHAR_STRICT_LESSTHAN, CHAR_STRICT_LESSTHAN_EQUAL, CHAR_STRING, CHAR_STRIP, CHAR_SUBCHAR, CHAR_SUBCLASS, CHAR_SUBCLASSES, CHAR_SUBSTR, CHAR_SUBTRACT, CHAR_SUBWORD, CHAR_SUPERCLASS, CHAR_SUPERCLASSES, CHAR_SUPPLIER, CHAR_SYSTEM, CHAR_TABLE, CHAR_TARGET, CHAR_TODIRECTORY, CHAR_TOSTRING, CHAR_TRANSLATE, CHAR_TRUE, CHAR_TRUNC, CHAR_UNINHERIT, CHAR_UNKNOWN, CHAR_UNSETMETHOD, CHAR_UPPER, CHAR_VALUE, CHAR_VARIABLES, CHAR_VERIFY, CHAR_VERSION, CHAR_WEAKREFERENCE, CHAR_WORD, CHAR_WORDINDEX, CHAR_WORDLENGTH, CHAR_WORDPOS, CHAR_WORDS, CHAR_X2B, CHAR_X2C, CHAR_X2D, CHAR_XOR, CLASS_CREATE, RexxInteger::classObject(), RexxNumberString::classObject(), RexxObject::classObject(), RexxList::classOf(), RexxString::compare(), RexxString::compareToRexx(), RexxMessage::completed(), RexxString::concatBlank(), RexxObject::concatBlank(), RexxString::concatRexx(), RexxObject::concatRexx(), RexxString::copies(), RexxContext::copyRexx(), RexxObject::copyRexx(), RexxMutableBuffer::countStrRexx(), RexxString::countStrRexx(), CPPM, create(), PackageClass::createInstance(), RexxSupplier::createInstance(), RexxIdentityTable::createInstance(), RexxRelation::createInstance(), RexxPointer::createInstance(), StackFrameClass::createInstance(), RexxTable::createInstance(), WeakReference::createInstance(), RexxQueue::createInstance(), RexxContext::createInstance(), RexxMessage::createInstance(), RexxDirectory::createInstance(), RoutineClass::createInstance(), RexxBuffer::createInstance(), RexxList::createInstance(), RexxMutableBuffer::createInstance(), RexxMethod::createInstance(), RexxStem::createInstance(), RexxArray::createInstance(), RexxNumberString::createInstance(), RexxString::createInstance(), RexxObject::createInstance(), Interpreter::createInterpreterInstance(), RexxActivity::createNewActivationStack(), createStrings(), ActivityManager::currentActivity, RexxInteger::d2c(), RexxNumberString::d2c(), RexxString::d2c(), RexxInteger::d2x(), RexxNumberString::d2x(), RexxString::d2x(), RexxString::dataType(), RexxString::decodeBase64(), RexxClass::defaultNameRexx(), RexxObject::defaultNameRexx(), RexxClass::defineClassMethod(), defineKernelMethod(), RexxClass::defineMethod(), RexxClass::defineMethods(), definePrivateKernelMethod(), defineProtectedKernelMethod(), RexxClass::deleteMethod(), RexxArray::deleteRexx(), RexxString::delstr(), RexxMutableBuffer::delWord(), RexxString::delWord(), PackageClass::digits(), RexxArray::dimension(), RexxInteger::divide(), RexxString::divide(), RexxNumberString::divide(), RexxDirectory::empty(), RexxHashTableCollection::empty(), RexxStem::empty(), RexxList::empty(), RexxArray::empty(), enableOrefChecks(), RexxString::encodeBase64(), RexxClass::enhanced(), RexxDirectory::entryRexx(), RexxPointer::equal(), RexxClass::equal(), RexxInteger::equal(), RexxNumberString::equal(), RexxString::equal(), RexxObject::equal(), RexxString::equals(), RexxActivity::error(), RexxMessage::errorCondition(), RexxArray::fill(), PackageClass::findClassRexx(), PackageClass::findRoutineRexx(), RexxList::firstItem(), RexxArray::firstItem(), RexxQueue::firstRexx(), RexxList::firstRexx(), RexxArray::firstRexx(), RexxInteger::floor(), RexxNumberString::floor(), RexxString::floor(), PackageClass::form(), RexxInteger::format(), RexxString::format(), RexxNumberString::formatRexx(), PackageClass::fuzz(), RexxContext::getArgs(), StackFrameClass::getArguments(), RexxClass::getBaseClass(), RexxMutableBuffer::getBufferSize(), PackageClass::getClasses(), RexxContext::getCondition(), RexxContext::getDigits(), RexxArray::getDimensions(), RexxContext::getExecutable(), StackFrameClass::getExecutable(), RexxContext::getForm(), RexxContext::getFuzz(), getGlobalName(), RexxClass::getId(), PackageClass::getImportedClasses(), PackageClass::getImportedPackages(), PackageClass::getImportedRoutines(), SystemInterpreter::getInternalSystemName(), RexxContext::getLine(), StackFrameClass::getLine(), RexxClass::getMetaClass(), PackageClass::getMethods(), PackageClass::getName(), StackFrameClass::getName(), RexxContext::getName(), RexxContext::getPackage(), BaseExecutable::getPackage(), PackageClass::getPublicClasses(), PackageClass::getPublicRoutines(), RexxHashTableCollection::getRexx(), RexxArray::getRexx(), PackageClass::getRoutines(), RexxContext::getRS(), PackageClass::getSource(), PackageClass::getSourceLineRexx(), PackageClass::getSourceSize(), RexxContext::getStackFrames(), RexxClass::getSubClasses(), RexxClass::getSuperClass(), RexxClass::getSuperClasses(), SystemInterpreter::getSystemName(), SystemInterpreter::getSystemVersion(), StackFrameClass::getTarget(), StackFrameClass::getTraceLine(), StackFrameClass::getType(), RexxContext::getVariables(), Interpreter::getVersionNumber(), RexxDirectory::hasEntry(), RexxMessage::hasError(), RexxInteger::hashCode(), RexxNumberString::hashCode(), RexxObject::hashCode(), RexxQueue::hasindex(), RexxDirectory::hasIndex(), RexxList::hasIndex(), RexxStem::hasIndex(), RexxHashTableCollection::hasIndexRexx(), RexxArray::hasIndexRexx(), RexxRelation::hasItem(), RexxDirectory::hasItem(), RexxStem::hasItem(), RexxList::hasItem(), RexxArray::hasItem(), RexxHashTableCollection::hasItemRexx(), RexxObject::hasMethodRexx(), RexxObject::identityHashRexx(), RexxSupplier::index(), RexxQueue::index(), RexxStem::index(), RexxList::index(), RexxArray::index(), RexxHashTableCollection::indexRexx(), RexxDirectory::indexRexx(), RexxClass::inherit(), Interpreter::init(), ActivityManager::init(), RexxObject::init(), PackageManager::initialize(), RexxActivity::initializeThreadContext(), RexxSupplier::initRexx(), RexxQueue::insert(), RexxMutableBuffer::insert(), RexxString::insert(), RexxList::insertRexx(), RexxArray::insertRexx(), RexxObject::instanceMethodRexx(), RexxObject::instanceMethodsRexx(), RexxInteger::integerDivide(), RexxString::integerDivide(), RexxNumberString::integerDivide(), IntegerEight, IntegerFive, IntegerFour, IntegerMinusOne, IntegerNine, IntegerOne, IntegerSeven, IntegerSix, IntegerThree, IntegerTwo, IntegerZero, RexxDirectory::isEmpty(), RexxHashTableCollection::isEmpty(), RexxStem::isEmpty(), RexxList::isEmpty(), RexxArray::isEmpty(), RexxInteger::isGreaterOrEqual(), RexxNumberString::isGreaterOrEqual(), RexxString::isGreaterOrEqual(), RexxInteger::isGreaterThan(), RexxNumberString::isGreaterThan(), RexxString::isGreaterThan(), RexxMethod::isGuardedRexx(), RexxObject::isInstanceOfRexx(), RexxInteger::isLessOrEqual(), RexxNumberString::isLessOrEqual(), RexxString::isLessOrEqual(), RexxInteger::isLessThan(), RexxNumberString::isLessThan(), RexxString::isLessThan(), RexxPointer::isNull(), RexxMethod::isPrivateRexx(), RexxMethod::isProtectedRexx(), RexxClass::isSubclassOf(), RexxTable::itemsRexx(), RexxDirectory::itemsRexx(), RexxList::itemsRexx(), RexxStem::itemsRexx(), RexxArray::itemsRexx(), kernel_public, RexxList::lastItem(), RexxArray::lastItem(), RexxMutableBuffer::lastPos(), RexxString::lastPosRexx(), RexxQueue::lastRexx(), RexxList::lastRexx(), RexxArray::lastRexx(), RexxString::left(), RexxMutableBuffer::lengthRexx(), RexxString::lengthRexx(), RexxMethod::loadExternalMethod(), RoutineClass::loadExternalRoutine(), PackageClass::loadLibrary(), PackageClass::loadPackage(), RexxLocal::local(), Interpreter::logicError(), RexxMutableBuffer::lower(), RexxString::lowerRexx(), RexxObject::makeArrayRexx(), RexxObject::makeString(), RexxObject::makeStringRexx(), RexxMutableBuffer::match(), RexxString::match(), RexxMutableBuffer::matchChar(), RexxString::matchChar(), RexxInteger::Max(), RexxNumberString::Max(), RexxString::Max(), memoryObject, RexxMessage::messageName(), RexxMessage::messageTarget(), RexxClass::method(), RexxClass::methods(), RexxInteger::Min(), RexxNumberString::Min(), RexxString::Min(), RexxInteger::minus(), RexxString::minus(), RexxNumberString::minus(), RexxClass::mixinclass(), RexxInteger::multiply(), RexxString::multiply(), RexxNumberString::multiply(), RexxMutableBuffer::mydelete(), new_directory(), new_integer(), new_string(), RoutineClass::newFileRexx(), RexxMethod::newFileRexx(), RexxMutableBufferClass::newRexx(), RexxQueue::newRexx(), RexxRelation::newRexx(), RexxIdentityTable::newRexx(), RexxTable::newRexx(), RexxPointer::newRexx(), WeakReference::newRexx(), RexxSupplierClass::newRexx(), RexxMessage::newRexx(), RoutineClass::newRexx(), RexxContext::newRexx(), StackFrameClass::newRexx(), RexxDirectory::newRexx(), PackageClass::newRexx(), RexxBuffer::newRexx(), RexxClass::newRexx(), RexxStem::newRexx(), RexxList::newRexx(), RexxMethod::newRexx(), RexxArray::newRexx(), RexxObject::newRexx(), RexxString::newRexx(), RexxSupplier::next(), RexxQueue::next(), RexxList::next(), RexxArray::nextRexx(), RexxPointer::notEqual(), RexxClass::notEqual(), RexxInteger::notEqual(), RexxNumberString::notEqual(), RexxString::notEqual(), RexxObject::notEqual(), RexxMessage::notify(), RexxInteger::notOp(), RexxString::notOp(), RexxNumberString::notOp(), RexxObject::objectName(), RexxObject::objectNameEquals(), RexxArray::of(), RexxQueue::ofRexx(), OREF_NULL, RexxInteger::orOp(), RexxString::orOp(), RexxNumberString::orOp(), RexxMutableBuffer::overlay(), RexxString::overlay(), RexxQueue::peek(), RexxInteger::plus(), RexxString::plus(), RexxNumberString::plus(), RexxMutableBuffer::posRexx(), RexxString::posRexx(), RexxInteger::power(), RexxString::power(), RexxNumberString::power(), RexxQueue::previous(), RexxList::previous(), RexxArray::previousRexx(), RexxQueue::pullRexx(), RexxQueue::pushRexx(), RexxRelation::put(), RexxQueue::put(), RexxDirectory::put(), RexxList::put(), RexxHashTableCollection::putRexx(), RexxArray::putRexx(), RexxClass::queryMixinClass(), RexxQueue::queueRexx(), RC_OK, RexxInteger::remainder(), RexxString::remainder(), RexxNumberString::remainder(), RexxQueue::remove(), RexxList::remove(), RexxStem::remove(), RexxRelation::removeAll(), RexxDirectory::removeItem(), RexxStem::removeItem(), RexxList::removeItem(), RexxArray::removeItem(), RexxRelation::removeItemRexx(), RexxHashTableCollection::removeItemRexx(), RexxHashTableCollection::removeRexx(), RexxDirectory::removeRexx(), RexxArray::removeRexx(), RexxMutableBuffer::replaceAt(), RexxString::replaceAt(), RexxStem::request(), RexxObject::requestRexx(), CPPCode::resolveExportedMethod(), RexxActivity::resolveProgramName(), RexxMessage::result(), ActivityManager::returnActivity(), RexxString::reverse(), RexxString::right(), RexxInteger::round(), RexxNumberString::round(), RexxString::round(), RexxObject::run(), RoutineClass::runProgram(), saveImage(), RexxQueue::section(), RexxList::section(), RexxArray::sectionRexx(), RexxMessage::send(), RexxObject::send(), RexxObject::sendWith(), RexxMutableBuffer::setBufferSize(), RexxDirectory::setEntry(), RexxMethod::setGuardedRexx(), setMarkTable(), RexxDirectory::setMethod(), RexxObject::setMethod(), RexxMethod::setPrivateRexx(), RexxMethod::setProtectedRexx(), RexxClass::setRexxDefined(), PackageClass::setSecurityManager(), RoutineClass::setSecurityManager(), RexxMethod::setSecurityManager(), RexxMethod::setUnguardedRexx(), RexxInteger::sign(), RexxString::sign(), RexxNumberString::Sign(), RexxArray::sizeRexx(), BaseExecutable::source(), RexxMutableBuffer::space(), RexxString::space(), RexxArray::stableSortRexx(), RexxArray::stableSortWithRexx(), RexxMessage::start(), RexxObject::start(), RexxObject::startWith(), RexxClass::strictEqual(), RexxInteger::strictEqual(), RexxNumberString::strictEqual(), RexxString::strictEqual(), RexxObject::strictEqual(), RexxInteger::strictGreaterOrEqual(), RexxNumberString::strictGreaterOrEqual(), RexxString::strictGreaterOrEqual(), RexxInteger::strictGreaterThan(), RexxNumberString::strictGreaterThan(), RexxString::strictGreaterThan(), RexxInteger::strictLessOrEqual(), RexxNumberString::strictLessOrEqual(), RexxString::strictLessOrEqual(), RexxInteger::strictLessThan(), RexxNumberString::strictLessThan(), RexxString::strictLessThan(), RexxInteger::strictNotEqual(), RexxNumberString::strictNotEqual(), RexxString::strictNotEqual(), RexxObject::strictNotEqual(), RexxObject::stringRexx(), RexxString::strip(), RexxMutableBuffer::subchar(), RexxString::subchar(), RexxClass::subclass(), RexxMutableBuffer::substr(), RexxString::substr(), RexxMutableBuffer::subWord(), RexxString::subWord(), RexxMutableBuffer::subWords(), RexxString::subWords(), RexxQueue::supplier(), RexxDirectory::supplier(), RexxHashTableCollection::supplier(), RexxStem::supplier(), RexxList::supplier(), RexxArray::supplier(), T_NilObject, TheArrayBehaviour, TheArrayClass, TheArrayClassBehaviour, TheBufferBehaviour, TheBufferClass, TheBufferClassBehaviour, TheClassBehaviour, TheClassClass, TheClassClassBehaviour, TheCommonRetrievers, TheDirectoryBehaviour, TheDirectoryClass, TheDirectoryClassBehaviour, TheEnvironment, TheFalseObject, TheFunctionsDirectory, TheIdentityTableBehaviour, TheIdentityTableClass, TheIdentityTableClassBehaviour, TheIntegerBehaviour, TheIntegerClass, TheIntegerClassBehaviour, TheKernel, TheListBehaviour, TheListClass, TheListClassBehaviour, TheMessageBehaviour, TheMessageClass, TheMessageClassBehaviour, TheMethodBehaviour, TheMethodClass, TheMethodClassBehaviour, TheMutableBufferBehaviour, TheMutableBufferClass, TheMutableBufferClassBehaviour, TheNilObject, TheNullArray, TheNullPointer, TheNumberStringBehaviour, TheNumberStringClass, TheNumberStringClassBehaviour, TheObjectBehaviour, TheObjectClass, TheObjectClassBehaviour, ThePackageBehaviour, ThePackageClass, ThePackageClassBehaviour, ThePointerBehaviour, ThePointerClass, ThePointerClassBehaviour, TheQueueBehaviour, TheQueueClass, TheQueueClassBehaviour, TheRelationBehaviour, TheRelationClass, TheRelationClassBehaviour, TheRexxContextBehaviour, TheRexxContextClass, TheRexxContextClassBehaviour, TheRoutineBehaviour, TheRoutineClass, TheRoutineClassBehaviour, TheStackFrameBehaviour, TheStackFrameClass, TheStackFrameClassBehaviour, TheStemBehaviour, TheStemClass, TheStemClassBehaviour, TheStringBehaviour, TheStringClass, TheStringClassBehaviour, TheSupplierBehaviour, TheSupplierClass, TheSupplierClassBehaviour, TheSystem, TheTableBehaviour, TheTableClass, TheTableClassBehaviour, TheTrueObject, TheWeakReferenceBehaviour, TheWeakReferenceClass, TheWeakReferenceClassBehaviour, RexxStem::toDirectory(), RexxArray::toString(), PackageClass::trace(), RexxMutableBuffer::translate(), RexxString::translate(), RexxInteger::trunc(), RexxNumberString::trunc(), RexxString::trunc(), RexxClass::uninherit(), RexxHashTableCollection::uniqueIndexes(), RexxObject::unknownRexx(), RexxObject::unsetMethod(), RexxMutableBuffer::upper(), RexxString::upperRexx(), RexxSupplier::value(), WeakReference::value(), RexxList::value(), VARIABLE_RC, VARIABLE_RESULT, VARIABLE_SELF, VARIABLE_SIGL, VARIABLE_SUPER, RexxMutableBuffer::verify(), RexxString::verify(), RexxMutableBuffer::word(), RexxString::word(), RexxMutableBuffer::wordIndex(), RexxString::wordIndex(), RexxMutableBuffer::wordLength(), RexxString::wordLength(), RexxMutableBuffer::wordPos(), RexxString::wordPos(), RexxMutableBuffer::words(), RexxString::words(), RexxString::x2b(), RexxString::x2c(), RexxString::x2d(), RexxInteger::xorOp(), RexxString::xorOp(), and RexxNumberString::xorOp().

Referenced by initialize().

◆ createLocks()

void RexxMemory::createLocks ( )
static

Definition at line 2243 of file RexxMemory.cpp.

References SysMutex::create(), envelopeMutex, flattenMutex, and unflattenMutex.

Referenced by create(), and Interpreter::processStartup().

◆ createStrings()

void RexxMemory::createStrings ( )
static

Definition at line 47 of file GlobalNames.cpp.

References globalStrings, and new_directory().

Referenced by createImage().

◆ defineKernelMethod()

void RexxMemory::defineKernelMethod ( const char *  name,
RexxBehaviour *  behaviour,
PCPPM  entryPoint,
size_t  arguments 
)
staticprivate

Definition at line 91 of file Setup.cpp.

References RexxInternalObject::behaviour, and RexxBehaviour::define().

Referenced by createImage().

◆ definePrivateKernelMethod()

void RexxMemory::definePrivateKernelMethod ( const char *  name,
RexxBehaviour *  behaviour,
PCPPM  entryPoint,
size_t  arguments 
)
staticprivate

Definition at line 117 of file Setup.cpp.

References RexxInternalObject::behaviour, RexxBehaviour::define(), RexxMethod::setPrivate(), and RexxMethod::setProtected().

Referenced by createImage().

◆ defineProtectedKernelMethod()

void RexxMemory::defineProtectedKernelMethod ( const char *  name,
RexxBehaviour *  behaviour,
PCPPM  entryPoint,
size_t  arguments 
)
staticprivate

Definition at line 103 of file Setup.cpp.

References RexxInternalObject::behaviour, RexxBehaviour::define(), and RexxMethod::setProtected().

Referenced by createImage().

◆ disableOrefChecks()

void RexxMemory::disableOrefChecks ( )
inline

Definition at line 258 of file RexxMemory.hpp.

References checkSetOK.

Referenced by RexxTable::addOffset(), RexxEnvelope::flattenReference(), initialize(), and saveImage().

◆ discardHoldObject()

void RexxMemory::discardHoldObject ( RexxInternalObject *  obj)

Definition at line 1629 of file RexxMemory.cpp.

References RexxStack::push(), RexxIdentityTable::remove(), saveStack, and saveTable.

Referenced by discardHoldObject().

◆ discardObject()

void RexxMemory::discardObject ( RexxInternalObject *  obj)
inline

Definition at line 209 of file RexxMemory.hpp.

References RexxIdentityTable::remove(), and saveTable.

Referenced by discardObject().

◆ dump()

RexxObject * RexxMemory::dump ( void  )

Definition at line 1771 of file RexxMemory.cpp.

References currentPool, dumpEnable, MemorySegmentSet::dumpSegments(), firstPool, RexxBehaviour::getPrimitiveBehaviour(), markWord, memoryObject, newSpaceLargeSegments, newSpaceNormalSegments, MemorySegmentPool::nextPool(), oldSpaceSegments, OREF_NULL, MemorySegmentPoolHeader::reserved, and T_Last_Exported_Class.

Referenced by RexxInstructionOptions::execute(), and gutCheck().

◆ dumpImageStats()

RexxObject * RexxMemory::dumpImageStats ( void  )

Definition at line 2157 of file RexxMemory.cpp.

References MemoryStats::clear(), MemorySegmentSet::gatherStats(), MemoryStats::largeStats, newSpaceLargeSegments, newSpaceNormalSegments, MemoryStats::normalStats, MemoryStats::printMemoryStats(), and TheNilObject.

◆ dumpMemoryProfile()

void RexxMemory::dumpMemoryProfile ( )

Definition at line 239 of file RexxMemory.cpp.

References NormalSegmentSet::dumpMemoryProfile(), LargeSegmentSet::dumpMemoryProfile(), newSpaceLargeSegments, and newSpaceNormalSegments.

◆ dumpObject()

void RexxMemory::dumpObject ( RexxObject *  objectRef,
FILE *  outfile 
)

Definition at line 251 of file RexxMemory.cpp.

References RexxInternalObject::getObjectSize(), and logMemoryCheck().

Referenced by checkSetOref(), and orphanCheckMark().

◆ enableOrefChecks()

void RexxMemory::enableOrefChecks ( )
inline

Definition at line 259 of file RexxMemory.hpp.

References checkSetOK.

Referenced by RexxTable::addOffset(), createImage(), RexxEnvelope::flattenReference(), and restore().

◆ flatten()

void RexxMemory::flatten ( RexxEnvelope *  env)
virtual

Reimplemented from RexxVirtualBase.

Definition at line 958 of file RexxMemory.cpp.

◆ getFlattenStack()

RexxStack * RexxMemory::getFlattenStack ( void  )

Definition at line 2129 of file RexxMemory.cpp.

References flattenMutex, flattenStack, LiveStackSize, SysMutex::request(), and SysMutex::requestImmediate().

Referenced by RexxEnvelope::pack().

◆ getGlobalName()

RexxString * RexxMemory::getGlobalName ( const char *  value)
static

Add a string to the global name table.

Parameters
valueThe new value to add.
Returns
The single instance of this string.

Definition at line 2277 of file RexxMemory.cpp.

References RexxDirectory::at(), globalStrings, new_string(), OREF_NULL, RexxDirectory::put(), and RexxInternalObject::stringValue().

Referenced by createImage(), RexxBehaviour::define(), and saveImage().

◆ getGlobalStrings()

RexxDirectory* RexxMemory::getGlobalStrings ( )
inline

Definition at line 276 of file RexxMemory.hpp.

References globalStrings.

Referenced by RexxSource::globalSetup().

◆ gutCheck()

RexxObject * RexxMemory::gutCheck ( void  )

Definition at line 1843 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, dump(), dumpEnable, RexxHashTableCollection::first(), RexxIdentityTable::get(), RexxBehaviour::getClassType(), RexxInteger::getValue(), RexxHashTableCollection::index(), OldSpaceSegmentSet::markOldSpaceObjects(), new_identity_table(), RexxHashTableCollection::next(), old2new, oldSpaceSegments, OREF_NULL, RexxIdentityTable::remove(), and restoreimage.

◆ holdObject()

RexxObject * RexxMemory::holdObject ( RexxInternalObject *  obj)

Definition at line 1638 of file RexxMemory.cpp.

References RexxStack::push(), and saveStack.

Referenced by holdObject(), and GlobalProtectedObject::~GlobalProtectedObject().

◆ initialize()

void RexxMemory::initialize ( bool  restoringImage)

Definition at line 160 of file RexxMemory.cpp.

References OldSpaceSegmentSet::allocateObject(), allocations, buildVirtualFunctionTable(), collections, createImage(), MemorySegmentPool::createPool(), currentPool, disableOrefChecks(), firstPool, NormalSegmentSet::getInitialSet(), globalStrings, liveStack, markTable, memoryObject, new_identity_table(), newSpaceLargeSegments, newSpaceNormalSegments, oldSpaceSegments, OREF_NULL, originalLiveStack, restore(), restoreImage(), SegmentDeadSpace, RexxInternalObject::setBehaviour(), TheMemoryBehaviour, uninitTable, and variableCache.

Referenced by Interpreter::startInterpreter().

◆ inObjectStorage()

bool RexxMemory::inObjectStorage ( RexxObject *  obj)
private

Definition at line 299 of file RexxMemory.cpp.

References RexxBehaviour::getPrimitiveBehaviour(), inSharedObjectStorage(), and T_Last_Class_Type.

Referenced by checkSetOref(), objectReferenceOK(), and orphanCheckMark().

◆ inSharedObjectStorage()

bool RexxMemory::inSharedObjectStorage ( RexxObject *  obj)
private

Definition at line 269 of file RexxMemory.cpp.

References MemorySegmentSet::isInSegmentSet(), newSpaceLargeSegments, newSpaceNormalSegments, and oldSpaceSegments.

Referenced by inObjectStorage().

◆ isPendingUninit()

bool RexxMemory::isPendingUninit ( RexxObject *  obj)

Definition at line 606 of file RexxMemory.cpp.

References RexxIdentityTable::get(), OREF_NULL, and uninitTable.

◆ killOrphans()

void RexxMemory::killOrphans ( RexxObject *  rootObject)

Definition at line 376 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, RexxInternalObject::hasReferences(), RexxObject::liveGeneral(), LIVEMARK, markReason, memory_mark_general, OREF_NULL, popLiveStack(), pushLiveStack(), and TheNilObject.

Referenced by markObjects().

◆ lastChanceUninit()

void RexxMemory::lastChanceUninit ( )

Force a last-gasp garbage collection and running of the uninits during interpreter instance shutdown. This is an attempt to ensure that all objects with uninit methods get a chance to clean up prior to termination.

Definition at line 497 of file RexxMemory.cpp.

References collectAndUninit(), RexxHashTableCollection::empty(), and uninitTable.

Referenced by Interpreter::terminateInterpreter().

◆ live()

void RexxMemory::live ( size_t  liveMark)
virtual

Reimplemented from RexxVirtualBase.

Definition at line 902 of file RexxMemory.cpp.

References envelope, globalStrings, ActivityManager::live(), PackageManager::live(), Interpreter::live(), SystemInterpreter::live(), markTable, memory_mark, GlobalProtectedObject::next, old2new, GlobalProtectedObject::protectedObject, protectedObjects, saveStack, saveTable, and variableCache.

◆ liveGeneral()

void RexxMemory::liveGeneral ( int  reason)
virtual

Reimplemented from RexxVirtualBase.

Definition at line 936 of file RexxMemory.cpp.

References envelope, globalStrings, ActivityManager::liveGeneral(), PackageManager::liveGeneral(), Interpreter::liveGeneral(), SystemInterpreter::liveGeneral(), markTable, memory_mark_general, old2new, saveStack, saveTable, and variableCache.

◆ liveStackFull()

void RexxMemory::liveStackFull ( )

Definition at line 1339 of file RexxMemory.cpp.

References RexxStack::copyEntries(), liveStack, originalLiveStack, and RexxStack::size.

Referenced by checkLiveStack().

◆ logObjectStats()

void RexxMemory::logObjectStats ( RexxObject *  obj)
inline

Definition at line 255 of file RexxMemory.hpp.

References imageStats, and MemoryStats::logObject().

Referenced by saveImageMark().

◆ logVerboseOutput()

void RexxMemory::logVerboseOutput ( const char *  message,
void *  sub1,
void *  sub2 
)

Definition at line 231 of file RexxMemory.cpp.

References logMemoryCheck().

Referenced by verboseMessage().

◆ makeProxy()

RexxObject * RexxMemory::makeProxy ( RexxEnvelope *  env)
virtual

Reimplemented from RexxInternalObject.

Definition at line 968 of file RexxMemory.cpp.

References new_proxy().

◆ mark()

void RexxMemory::mark ( RexxObject *  markObject)

Definition at line 1356 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, RexxInternalObject::hasNoReferences(), markWord, ObjectNeedsMarking, OldSpaceBit, pushLiveStack(), and RexxInternalObject::setObjectLive().

Referenced by markObjectsMain(), objectIsLive(), objectIsNotLive(), and MemorySegmentSet::sweep().

◆ markGeneral()

void RexxMemory::markGeneral ( void *  obj)

Definition at line 1414 of file RexxMemory.cpp.

References envelope, Interpreter::logicError(), objOffset, OREF_NULL, orphanCheck, orphanCheckMark(), restoreimage, restoreMark(), restoreObjectMark(), saveimage, saveImageMark(), and unflattenMark().

◆ markObjects()

void RexxMemory::markObjects ( void  )

Definition at line 615 of file RexxMemory.cpp.

References checkUninit(), checkWeakReferences(), killOrphans(), liveStack, markObjectsMain(), originalLiveStack, orphanCheck, uninitTable, and verboseMessage().

Referenced by collect().

◆ markObjectsMain()

void RexxMemory::markObjectsMain ( RexxObject *  rootObject)

Definition at line 341 of file RexxMemory.cpp.

References allocations, RexxInternalObject::behaviour, RexxObject::live(), mark(), markWord, memory_mark, OldSpaceBit, OREF_NULL, popLiveStack(), and pushLiveStack().

Referenced by markObjects().

◆ memoryPoolAdded()

void RexxMemory::memoryPoolAdded ( MemorySegmentPool *  pool)

Add a new pool to the memory set.

Parameters
poolThe new pool.

Definition at line 2182 of file RexxMemory.cpp.

References currentPool.

Referenced by MemorySegmentPool::newLargeSegment(), and MemorySegmentPool::newSegment().

◆ newLargeSegment()

MemorySegment * RexxMemory::newLargeSegment ( size_t  requestLength,
size_t  minLength 
)

Definition at line 753 of file RexxMemory.cpp.

References currentPool, MemorySegmentOverhead, MemorySegmentPool::newLargeSegment(), and roundSegmentBoundary().

Referenced by LargeSegmentSet::allocateSegment().

◆ newObject() [1/2]

RexxObject* RexxMemory::newObject ( size_t  size)
inline

Definition at line 190 of file RexxMemory.hpp.

References newObject(), and T_Object.

Referenced by OldSpaceSegmentSet::allocateObject(), NormalSegmentSet::handleAllocationFailure(), LargeSegmentSet::handleAllocationFailure(), new_object(), and newObject().

◆ newObject() [2/2]

RexxObject * RexxMemory::newObject ( size_t  size,
size_t  type 
)

Definition at line 1072 of file RexxMemory.cpp.

References NormalSegmentSet::allocateObject(), LargeSegmentSet::allocateObject(), allocations, RexxBehaviour::getPrimitiveBehaviour(), NormalSegmentSet::handleAllocationFailure(), LargeSegmentSet::handleAllocationFailure(), RexxObject::initializeNewObject(), LargeBlockThreshold, markWord, MinimumObjectSize, newSpaceLargeSegments, newSpaceNormalSegments, OREF_NULL, pushSaveStack(), roundLargeObjectAllocation(), roundObjectBoundary(), saveStack, type, and virtualFunctionTable.

◆ newObjects()

RexxArray * RexxMemory::newObjects ( size_t  size,
size_t  count,
size_t  objectType 
)

Definition at line 1133 of file RexxMemory.cpp.

References NormalSegmentSet::allocateObject(), LargeSegmentSet::allocateObject(), RexxInternalObject::clearObject(), RexxInternalObject::getObjectSize(), RexxBehaviour::getPrimitiveBehaviour(), NormalSegmentSet::handleAllocationFailure(), LargeSegmentSet::handleAllocationFailure(), RexxObject::initializeNewObject(), LargeBlockThreshold, markWord, new_array(), newSpaceLargeSegments, newSpaceNormalSegments, OREF_NULL, pushSaveStack(), RexxArray::put(), roundObjectBoundary(), saveStack, RexxInternalObject::setObjectSize(), T_Object, TheObjectBehaviour, and virtualFunctionTable.

Referenced by new_arrayOfObject(), and new_arrayOfTokens().

◆ newSegment()

MemorySegment * RexxMemory::newSegment ( size_t  requestLength,
size_t  minLength 
)

Definition at line 713 of file RexxMemory.cpp.

References currentPool, MemorySegmentOverhead, MemorySegmentPool::newSegment(), and roundSegmentBoundary().

Referenced by MemorySegmentSet::allocateSegment(), MemorySegment::insertAfter(), MemorySegment::insertBefore(), and NormalSegmentSet::NormalSegmentSet().

◆ objectReferenceOK()

bool RexxMemory::objectReferenceOK ( RexxObject *  o)
private

Definition at line 318 of file RexxMemory.cpp.

References RexxInternalObject::getObjectType(), RexxBehaviour::getPrimitiveBehaviour(), inObjectStorage(), T_Behaviour, TheBehaviourBehaviour, and type.

Referenced by checkSetOref(), and orphanCheckMark().

◆ oldObject()

RexxObject * RexxMemory::oldObject ( size_t  size)

Definition at line 1034 of file RexxMemory.cpp.

References OldSpaceSegmentSet::allocateObject(), RexxObject::initializeNewObject(), markWord, oldSpaceSegments, OREF_NULL, roundObjectBoundary(), T_Object, TheObjectBehaviour, and virtualFunctionTable.

Referenced by allocateImageBuffer().

◆ operator RexxObject *()

RexxMemory::operator RexxObject * ( )
inline

Definition at line 178 of file RexxMemory.hpp.

◆ operator=()

RexxObject* RexxMemory::operator= ( DeadObject *  d)
inline

Definition at line 179 of file RexxMemory.hpp.

◆ orphanCheckMark()

void RexxMemory::orphanCheckMark ( RexxObject *  markObject,
RexxObject **  pMarkObject 
)
private

Definition at line 1543 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, dumpObject(), RexxBehaviour::getClassType(), RexxString::getStringData(), SysFileSystem::getTempFileName(), RexxObject::id(), inObjectStorage(), RexxInternalObject::isNewSpace(), RexxInternalObject::isObjectLive(), Interpreter::logicError(), logMemoryCheck(), markWord, objectReferenceOK(), OREF_NULL, popLiveStack(), pushLiveStack(), RexxInternalObject::setObjectLive(), and TheNilObject.

Referenced by markGeneral().

◆ popLiveStack()

RexxObject* RexxMemory::popLiveStack ( )
inlineprivate

Definition at line 333 of file RexxMemory.hpp.

References RexxStack::fastPop(), and liveStack.

Referenced by killOrphans(), markObjectsMain(), orphanCheckMark(), and saveImage().

◆ pushLiveStack()

void RexxMemory::pushLiveStack ( RexxObject *  obj)
inlineprivate

Definition at line 332 of file RexxMemory.hpp.

References checkLiveStack(), RexxStack::fastPush(), and liveStack.

Referenced by killOrphans(), mark(), markObjectsMain(), orphanCheckMark(), saveImage(), and saveImageMark().

◆ pushSaveStack()

void RexxMemory::pushSaveStack ( RexxObject *  obj)
inline

Definition at line 256 of file RexxMemory.hpp.

References RexxStack::push(), and saveStack.

Referenced by newObject(), and newObjects().

◆ queryDump()

bool RexxMemory::queryDump ( )
inline

Definition at line 217 of file RexxMemory.hpp.

References dumpEnable.

◆ reclaim()

RexxObject * RexxMemory::reclaim ( )

Definition at line 989 of file RexxMemory.cpp.

References collect(), and OREF_NULL.

◆ removeHold()

void RexxMemory::removeHold ( RexxInternalObject *  obj)
inline

Definition at line 210 of file RexxMemory.hpp.

References RexxSaveStack::remove(), and saveStack.

◆ removeSavedObject()

void RexxMemory::removeSavedObject ( RexxObject *  obj)
inline

Definition at line 257 of file RexxMemory.hpp.

References RexxSaveStack::remove(), and saveStack.

◆ removeUninitObject()

void RexxMemory::removeUninitObject ( RexxObject *  obj)

Definition at line 578 of file RexxMemory.cpp.

References RexxIdentityTable::remove(), and uninitTable.

Referenced by RexxInternalObject::removedUninit().

◆ reSize()

void RexxMemory::reSize ( RexxObject *  shrinkObj,
size_t  requestSize 
)

Definition at line 1249 of file RexxMemory.cpp.

References DeadObject::getObjectSize(), RexxInternalObject::getObjectSize(), MinimumObjectSize, roundObjectResize(), and RexxInternalObject::setObjectSize().

Referenced by RexxArray::resize().

◆ restore()

void RexxMemory::restore ( )
static

Definition at line 2317 of file RexxMemory.cpp.

References enableOrefChecks(), Interpreter::init(), ActivityManager::init(), IntegerEight, IntegerFive, IntegerFour, IntegerMinusOne, IntegerNine, IntegerOne, IntegerSeven, IntegerSix, IntegerThree, IntegerTwo, IntegerZero, memoryObject, new_identity_table(), new_integer(), PackageManager::restore(), RESTORE_CLASS, RexxInternalObject::setOldSpace(), and setUpMemoryTables().

Referenced by initialize().

◆ restoreImage()

void RexxMemory::restoreImage ( )
private

Definition at line 790 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, RexxArray::get(), RexxBehaviour::getClassType(), RexxInternalObject::getObjectSize(), RexxInternalObject::hasReferences(), image_buffer, RexxActivity::initializeThreadContext(), RexxInternalObject::isNonPrimitive(), SystemInterpreter::loadImage(), markReason, memoryObject, RexxBehaviour::primitiveBehaviours, relocation, PackageManager::restore(), RexxBehaviour::restore(), restoreimage, RexxBehaviour::restoreSavedPrimitiveBehaviour(), restoreStrings(), RESTORINGIMAGE, saveArray_CLASS, saveArray_COMMON_RETRIEVERS, saveArray_ENV, saveArray_FALSE, saveArray_FUNCTIONS, saveArray_KERNEL, saveArray_NAME_STRINGS, saveArray_NIL, saveArray_NULLA, saveArray_NULLPOINTER, saveArray_PACKAGES, saveArray_PBEHAV, saveArray_SYSTEM, saveArray_TRUE, T_Last_Exported_Class, TheClassClass, TheCommonRetrievers, TheEnvironment, TheFalseObject, TheFunctionsDirectory, TheKernel, TheNilObject, TheNullArray, TheNullPointer, TheSystem, TheTrueObject, and virtualFunctionTable.

Referenced by initialize().

◆ restoreMark()

void RexxMemory::restoreMark ( RexxObject *  markObject,
RexxObject **  pMarkObject 
)
inlineprivate

Definition at line 335 of file RexxMemory.hpp.

References relocation.

Referenced by markGeneral().

◆ restoreObjectMark()

void RexxMemory::restoreObjectMark ( RexxObject *  markObject,
RexxObject **  pMarkObject 
)
inlineprivate

Definition at line 345 of file RexxMemory.hpp.

References markWord, objOffset, and RexxInternalObject::setObjectLive().

Referenced by markGeneral().

◆ restoreStrings()

void RexxMemory::restoreStrings ( RexxArray *  stringArray)
static

Definition at line 92 of file GlobalNames.cpp.

References RexxArray::data().

Referenced by restoreImage().

◆ restoringImage()

bool RexxMemory::restoringImage ( )
inline

Definition at line 215 of file RexxMemory.hpp.

References restoreimage.

Referenced by RexxBehaviour::liveGeneral().

◆ returnFlattenStack()

void RexxMemory::returnFlattenStack ( void  )

Definition at line 2148 of file RexxMemory.cpp.

References flattenMutex, flattenStack, and SysMutex::release().

Referenced by RexxEnvelope::pack().

◆ runUninits()

void RexxMemory::runUninits ( )

Definition at line 507 of file RexxMemory.cpp.

References ActivityManager::currentActivity, RexxHashTableCollection::first(), RexxHashTableCollection::index(), RexxHashTableCollection::next(), OREF_NULL, pendingUninits, processingUninits, RexxIdentityTable::put(), RexxIdentityTable::remove(), RexxActivity::run(), TheFalseObject, TheTrueObject, uninitTable, and RexxHashTableCollection::value().

Referenced by checkUninitQueue(), collectAndUninit(), RexxActivity::exitCurrentThread(), RexxActivity::run(), and RexxActivity::runThread().

◆ saveImage()

void RexxMemory::saveImage ( void  )

Definition at line 1657 of file RexxMemory.cpp.

References BASEIMAGE, RexxInternalObject::behaviour, bumpMarkWord(), CHAR_KERNEL, CHAR_MEMORY, MemoryStats::clear(), disableOrefChecks(), getGlobalName(), PackageManager::getImageData(), RexxBehaviour::getPrimitiveBehaviour(), globalStrings, image_buffer, image_offset, imageStats, RexxInternalObject::isNonPrimitive(), RexxObject::liveGeneral(), markReason, MaxImageSize, memory_mark_general, memoryObject, new_array(), old2new, OREF_NULL, OrefSet, popLiveStack(), MemoryStats::printSavedImageStats(), pushLiveStack(), RexxArray::put(), saveArray_CLASS, saveArray_COMMON_RETRIEVERS, saveArray_ENV, saveArray_FALSE, saveArray_FUNCTIONS, saveArray_highest, saveArray_KERNEL, saveArray_NAME_STRINGS, saveArray_NIL, saveArray_NULLA, saveArray_NULLPOINTER, saveArray_PACKAGES, saveArray_PBEHAV, saveArray_SYSTEM, saveArray_TRUE, saveimage, saveObject(), saveStack, saveStrings(), saveTable, SAVINGIMAGE, T_Last_Exported_Class, TheClassClass, TheCommonRetrievers, TheEnvironment, TheFalseObject, TheFunctionsDirectory, TheKernel, TheNilObject, TheNullArray, TheNullPointer, TheSystem, and TheTrueObject.

Referenced by createImage().

◆ saveImageMark()

void RexxMemory::saveImageMark ( RexxObject *  markObject,
RexxObject **  pMarkObject 
)
private

Definition at line 1475 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, RexxInternalObject::clearObjectMark(), RexxInternalObject::getObjectSize(), RexxBehaviour::getSavedPrimitiveBehaviour(), image_buffer, image_offset, RexxInternalObject::isNewSpace(), RexxBehaviour::isNonPrimitive(), RexxInternalObject::isObjectLive(), RexxBehaviour::isTransientClass(), Interpreter::logicError(), logObjectStats(), markWord, MaxImageSize, OREF_NULL, pushLiveStack(), RexxInternalObject::setNonPrimitive(), RexxInternalObject::setObjectLive(), and RexxInternalObject::setPrimitive().

Referenced by markGeneral().

◆ saveObject()

RexxObject* RexxMemory::saveObject ( RexxInternalObject *  saveObj)
inline

Definition at line 208 of file RexxMemory.hpp.

References RexxIdentityTable::add(), and saveTable.

Referenced by saveImage(), and saveObject().

◆ saveStrings()

RexxArray * RexxMemory::saveStrings ( )
static

Definition at line 64 of file GlobalNames.cpp.

References new_array().

Referenced by saveImage().

◆ savingImage()

bool RexxMemory::savingImage ( )
inline

Definition at line 214 of file RexxMemory.hpp.

References saveimage.

Referenced by ActivityManager::liveGeneral(), RexxBehaviour::liveGeneral(), Interpreter::liveGeneral(), SystemInterpreter::liveGeneral(), and RexxSource::liveGeneral().

◆ scavengeSegmentSets()

void RexxMemory::scavengeSegmentSets ( MemorySegmentSet *  requester,
size_t  allocationLength 
)

Definition at line 1293 of file RexxMemory.cpp.

References MemorySegmentSet::addDeadObject(), MemorySegmentSet::addSegment(), MemorySegmentSet::donateObject(), MemorySegmentSet::donateSegment(), MemorySegmentSet::is(), newSpaceLargeSegments, newSpaceNormalSegments, and MemorySegmentSet::SET_NORMAL.

Referenced by NormalSegmentSet::handleAllocationFailure(), and LargeSegmentSet::handleAllocationFailure().

◆ setDump()

RexxObject * RexxMemory::setDump ( RexxObject *  selection)

Definition at line 1829 of file RexxMemory.cpp.

References dumpEnable, Error_Logical_value_method, OREF_NULL, and RexxObject::truthValue().

◆ setEnvelope()

void RexxMemory::setEnvelope ( RexxEnvelope *  _envelope)

Definition at line 1962 of file RexxMemory.cpp.

References envelope, envelopeMutex, OREF_NULL, SysMutex::release(), SysMutex::request(), and SysMutex::requestImmediate().

Referenced by RexxEnvelope::puff().

◆ setMarkTable()

void RexxMemory::setMarkTable ( RexxTable *  marktable)
inline

Definition at line 222 of file RexxMemory.hpp.

References markTable.

Referenced by createImage().

◆ setObjectOffset()

void RexxMemory::setObjectOffset ( size_t  offset)

Definition at line 1927 of file RexxMemory.cpp.

References objOffset, SysMutex::release(), SysMutex::request(), SysMutex::requestImmediate(), and unflattenMutex.

Referenced by RexxEnvelope::puff().

◆ setOref()

RexxObject * RexxMemory::setOref ( void *  index,
RexxObject *  value 
)

index

Definition at line 1996 of file RexxMemory.cpp.

References RexxInternalObject::behaviour, RexxInteger::decrementValue(), RexxIdentityTable::get(), RexxBehaviour::getClassType(), RexxInteger::getValue(), RexxInteger::incrementValue(), RexxInternalObject::isNewSpace(), old2new, OREF_NULL, RexxIdentityTable::put(), and RexxIdentityTable::remove().

Referenced by checkSetOref().

◆ setOrphanCheck()

void RexxMemory::setOrphanCheck ( bool  orphancheck)
inline

Definition at line 223 of file RexxMemory.hpp.

References orphanCheck.

◆ setParms()

RexxObject * RexxMemory::setParms ( RexxObject *  deadSegs,
RexxObject *  notUsed 
)

Definition at line 1649 of file RexxMemory.cpp.

References OREF_NULL.

◆ setUpMemoryTables()

void RexxMemory::setUpMemoryTables ( RexxIdentityTable *  old2newTable)

Definition at line 2210 of file RexxMemory.cpp.

References RexxStack::init(), liveStack, LiveStackSize, markTable, new_identity_table(), old2new, OrefSet, RexxIdentityTable::put(), saveStack, SaveStackAllocSize, SaveStackSize, saveTable, RexxInternalObject::setBehaviour(), and TheStackBehaviour.

Referenced by create(), and restore().

◆ shutdown()

void RexxMemory::shutdown ( )

Definition at line 2188 of file RexxMemory.cpp.

References currentPool, firstPool, MemorySegmentPool::freePool(), and MemorySegmentPool::nextPool().

◆ temporaryObject()

RexxObject * RexxMemory::temporaryObject ( size_t  size)

Definition at line 1390 of file RexxMemory.cpp.

References Error_System_resources, RexxObject::initializeNewObject(), markWord, OREF_NULL, reportException(), roundObjectBoundary(), T_Object, TheObjectBehaviour, and virtualFunctionTable.

Referenced by RexxStack::operator new().

◆ unflattenMark()

void RexxMemory::unflattenMark ( RexxObject *  markObject,
RexxObject **  pMarkObject 
)
inlineprivate

Definition at line 340 of file RexxMemory.hpp.

References envelope, and RexxVirtualBase::unflatten().

Referenced by markGeneral().

◆ verboseMessage() [1/3]

void RexxMemory::verboseMessage ( const char *  message)
inline

Definition at line 237 of file RexxMemory.hpp.

References logVerboseOutput().

Referenced by MemorySegmentSet::addSegment(), MemorySegmentSet::adjustMemorySize(), collect(), MemorySegmentSet::combineEmptySegments(), LargeSegmentSet::completeSweepOperation(), LargeSegmentSet::expandSegmentSet(), markObjects(), MemorySegmentSet::mergeSegments(), and NormalSegmentSet::suggestMemoryExpansion().

◆ verboseMessage() [2/3]

void RexxMemory::verboseMessage ( const char *  message,
size_t  sub1 
)
inline

Definition at line 243 of file RexxMemory.hpp.

References logVerboseOutput().

◆ verboseMessage() [3/3]

void RexxMemory::verboseMessage ( const char *  message,
size_t  sub1,
size_t  sub2 
)
inline

Definition at line 249 of file RexxMemory.hpp.

References logVerboseOutput().

Member Data Documentation

◆ allocations

size_t RexxMemory::allocations
private

Definition at line 400 of file RexxMemory.hpp.

Referenced by collect(), initialize(), markObjectsMain(), and newObject().

◆ checkSetOK

bool RexxMemory::checkSetOK
private

Definition at line 389 of file RexxMemory.hpp.

Referenced by checkSetOref(), disableOrefChecks(), and enableOrefChecks().

◆ collections

size_t RexxMemory::collections
private

Definition at line 401 of file RexxMemory.hpp.

Referenced by collect(), and initialize().

◆ commonRetrievers

RexxDirectory * RexxMemory::commonRetrievers = OREF_NULL
static

Definition at line 299 of file RexxMemory.hpp.

◆ currentPool

MemorySegmentPool* RexxMemory::currentPool
private

Definition at line 379 of file RexxMemory.hpp.

Referenced by dump(), initialize(), memoryPoolAdded(), newLargeSegment(), newSegment(), RexxMemory(), and shutdown().

◆ dumpEnable

bool RexxMemory::dumpEnable
private

Definition at line 386 of file RexxMemory.hpp.

Referenced by dump(), RexxInstructionOptions::execute(), gutCheck(), queryDump(), RexxMemory(), and setDump().

◆ envelope

RexxEnvelope* RexxMemory::envelope
private

Definition at line 396 of file RexxMemory.hpp.

Referenced by live(), liveGeneral(), markGeneral(), RexxMemory(), setEnvelope(), and unflattenMark().

◆ envelopeMutex

SysMutex RexxMemory::envelopeMutex
staticprivate

Definition at line 407 of file RexxMemory.hpp.

Referenced by closeLocks(), createLocks(), and setEnvelope().

◆ environment

RexxDirectory * RexxMemory::environment = OREF_NULL
static

Definition at line 297 of file RexxMemory.hpp.

◆ exportedMethods

PCPPM RexxMemory::exportedMethods[]
static

Definition at line 290 of file RexxMemory.hpp.

◆ firstPool

MemorySegmentPool* RexxMemory::firstPool
private

Definition at line 378 of file RexxMemory.hpp.

Referenced by dump(), initialize(), RexxMemory(), and shutdown().

◆ flattenMutex

SysMutex RexxMemory::flattenMutex
staticprivate

Definition at line 405 of file RexxMemory.hpp.

Referenced by closeLocks(), createLocks(), getFlattenStack(), and returnFlattenStack().

◆ flattenStack

RexxStack* RexxMemory::flattenStack
private

Definition at line 367 of file RexxMemory.hpp.

Referenced by getFlattenStack(), and returnFlattenStack().

◆ functionsDir

RexxDirectory * RexxMemory::functionsDir = OREF_NULL
static

Definition at line 298 of file RexxMemory.hpp.

◆ globalStrings

RexxDirectory * RexxMemory::globalStrings = OREF_NULL
staticprivate

Definition at line 404 of file RexxMemory.hpp.

Referenced by createStrings(), getGlobalName(), getGlobalStrings(), initialize(), live(), liveGeneral(), and saveImage().

◆ image_buffer

char* RexxMemory::image_buffer
private

Definition at line 383 of file RexxMemory.hpp.

Referenced by restoreImage(), saveImage(), and saveImageMark().

◆ image_offset

size_t RexxMemory::image_offset
private

Definition at line 384 of file RexxMemory.hpp.

Referenced by saveImage(), and saveImageMark().

◆ imageStats

MemoryStats* RexxMemory::imageStats
private

Definition at line 398 of file RexxMemory.hpp.

Referenced by logObjectStats(), and saveImage().

◆ kernel

RexxDirectory * RexxMemory::kernel = OREF_NULL
static

Definition at line 300 of file RexxMemory.hpp.

◆ liveStack

RexxStack* RexxMemory::liveStack
private

Definition at line 366 of file RexxMemory.hpp.

Referenced by checkLiveStack(), initialize(), liveStackFull(), markObjects(), popLiveStack(), pushLiveStack(), and setUpMemoryTables().

◆ markReason

int RexxMemory::markReason

Definition at line 293 of file RexxMemory.hpp.

Referenced by killOrphans(), restoreImage(), and saveImage().

◆ markTable

RexxTable* RexxMemory::markTable
private

Definition at line 370 of file RexxMemory.hpp.

Referenced by initialize(), live(), liveGeneral(), setMarkTable(), and setUpMemoryTables().

◆ markWord

size_t RexxMemory::markWord

Definition at line 292 of file RexxMemory.hpp.

Referenced by bumpMarkWord(), checkUninit(), checkWeakReferences(), dump(), MemorySegment::firstDeadObject(), MemorySegment::lastDeadObject(), mark(), markObjectsMain(), RexxHashTable::newInstance(), newObject(), newObjects(), oldObject(), RexxListTable::operator new(), orphanCheckMark(), RexxEnvelope::puff(), SegmentStats::recordObject(), restoreObjectMark(), RexxMemory(), saveImageMark(), MemorySegmentSet::splitSegment(), MemorySegmentSet::sweep(), and temporaryObject().

◆ newSpaceLargeSegments

LargeSegmentSet RexxMemory::newSpaceLargeSegments
private

Definition at line 382 of file RexxMemory.hpp.

Referenced by collect(), dump(), dumpImageStats(), dumpMemoryProfile(), initialize(), inSharedObjectStorage(), newObject(), newObjects(), and scavengeSegmentSets().

◆ newSpaceNormalSegments

NormalSegmentSet RexxMemory::newSpaceNormalSegments
private

Definition at line 381 of file RexxMemory.hpp.

Referenced by collect(), dump(), dumpImageStats(), dumpMemoryProfile(), initialize(), inSharedObjectStorage(), newObject(), newObjects(), and scavengeSegmentSets().

◆ objOffset

size_t RexxMemory::objOffset
private

Definition at line 393 of file RexxMemory.hpp.

Referenced by markGeneral(), restoreObjectMark(), RexxMemory(), and setObjectOffset().

◆ old2new

RexxIdentityTable* RexxMemory::old2new
private

Definition at line 373 of file RexxMemory.hpp.

Referenced by gutCheck(), live(), liveGeneral(), saveImage(), setOref(), and setUpMemoryTables().

◆ oldSpaceSegments

OldSpaceSegmentSet RexxMemory::oldSpaceSegments
private

Definition at line 380 of file RexxMemory.hpp.

Referenced by dump(), gutCheck(), initialize(), inSharedObjectStorage(), and oldObject().

◆ originalLiveStack

RexxStack* RexxMemory::originalLiveStack
private

Definition at line 397 of file RexxMemory.hpp.

Referenced by initialize(), liveStackFull(), and markObjects().

◆ orphanCheck

bool RexxMemory::orphanCheck
private

Definition at line 392 of file RexxMemory.hpp.

Referenced by markGeneral(), markObjects(), RexxMemory(), and setOrphanCheck().

◆ pendingUninits

size_t RexxMemory::pendingUninits
private

Definition at line 375 of file RexxMemory.hpp.

Referenced by checkUninit(), checkUninitQueue(), and runUninits().

◆ processingUninits

bool RexxMemory::processingUninits
private

Definition at line 376 of file RexxMemory.hpp.

Referenced by runUninits().

◆ protectedObjects

GlobalProtectedObject* RexxMemory::protectedObjects

Definition at line 295 of file RexxMemory.hpp.

Referenced by GlobalProtectedObject::GlobalProtectedObject(), live(), and GlobalProtectedObject::~GlobalProtectedObject().

◆ relocation

size_t RexxMemory::relocation
private

Definition at line 385 of file RexxMemory.hpp.

Referenced by restoreImage(), and restoreMark().

◆ restoreimage

bool RexxMemory::restoreimage
private

Definition at line 388 of file RexxMemory.hpp.

Referenced by gutCheck(), markGeneral(), restoreImage(), and restoringImage().

◆ saveimage

bool RexxMemory::saveimage
private

Definition at line 387 of file RexxMemory.hpp.

Referenced by markGeneral(), saveImage(), and savingImage().

◆ saveStack

RexxSaveStack* RexxMemory::saveStack
private

Definition at line 368 of file RexxMemory.hpp.

Referenced by clearSaveStack(), discardHoldObject(), holdObject(), live(), liveGeneral(), newObject(), newObjects(), pushSaveStack(), removeHold(), removeSavedObject(), RexxMemory(), saveImage(), and setUpMemoryTables().

◆ saveTable

RexxIdentityTable* RexxMemory::saveTable
private

Definition at line 369 of file RexxMemory.hpp.

Referenced by collect(), discardHoldObject(), discardObject(), live(), liveGeneral(), RexxMemory(), saveImage(), saveObject(), and setUpMemoryTables().

◆ system

RexxDirectory * RexxMemory::system = OREF_NULL
static

Definition at line 301 of file RexxMemory.hpp.

◆ unflattenMutex

SysMutex RexxMemory::unflattenMutex
staticprivate

Definition at line 406 of file RexxMemory.hpp.

Referenced by closeLocks(), createLocks(), and setObjectOffset().

◆ uninitTable

RexxIdentityTable* RexxMemory::uninitTable
private

Definition at line 374 of file RexxMemory.hpp.

Referenced by addUninitObject(), checkUninit(), initialize(), isPendingUninit(), lastChanceUninit(), markObjects(), removeUninitObject(), and runUninits().

◆ variableCache

RexxVariable* RexxMemory::variableCache

Definition at line 294 of file RexxMemory.hpp.

Referenced by RexxActivation::cacheLocalVariable(), initialize(), live(), liveGeneral(), and RexxActivation::newLocalVariable().

◆ virtualFunctionTable

void * RexxMemory::virtualFunctionTable = {NULL}
static

Definition at line 289 of file RexxMemory.hpp.

Referenced by buildVirtualFunctionTable(), RexxHashTable::newInstance(), newObject(), newObjects(), oldObject(), RexxListTable::operator new(), RexxNilObject::operator new(), RexxEnvelope::puff(), restoreImage(), and temporaryObject().

◆ weakReferenceList

WeakReference* RexxMemory::weakReferenceList
private

Definition at line 402 of file RexxMemory.hpp.

Referenced by addWeakReference(), checkWeakReferences(), and RexxMemory().

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