/**
* Normal live marking.
*/
void LibraryPackage::live(size_t liveMark)
{
memory_mark(libraryName);
memory_mark(routines);
memory_mark(publicRoutines);
memory_mark(methods);
}
/**
* Normal garbage collection live marking
*
* @param liveMark The current live mark.
*/
void DirectoryClass::live(size_t liveMark)
{
memory_mark(contents);
memory_mark(methodTable);
memory_mark(unknownMethod);
memory_mark(objectVariables);
}
/**
* Generalized object marking.
*
* @param reason The reason for this live marking operation.
*/
void StemClass::live(size_t liveMark)
{
memory_mark(value);
memory_mark(stemName);
memory_mark(objectVariables);
markCompoundTable();
}
/**
* Perform garbage collection on a live object.
*
* @param liveMark The current live mark.
*/
void RexxInstructionIf::live(size_t liveMark)
{
// must be first object marked.
memory_mark(nextInstruction);
memory_mark(condition);
memory_mark(else_location);
}
/**
* Normal live marking.
*/
void PackageManager::live(size_t liveMark)
{
memory_mark(packages);
memory_mark(packageRoutines);
memory_mark(registeredRoutines);
memory_mark(loadedRequires);
}
void RexxHashTableCollection::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->contents);
memory_mark(this->objectVariables);
}
/**
* Perform garbage collection on a live object.
*
* @param liveMark The current live mark.
*/
void MethodClass::live(size_t liveMark)
{
memory_mark(scope);
memory_mark(code);
memory_mark(executableName);
memory_mark(objectVariables);
memory_mark(annotations);
}
void RexxInstructionExpression::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->nextInstruction);
memory_mark(this->expression);
}
void RexxInstructionTrace::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->nextInstruction); /* must be first one marked */
memory_mark(this->expression);
}
void RexxVariable::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->variableValue);
memory_mark(this->variable_name);
memory_mark(this->dependents);
}
void RexxCode::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->source);
memory_mark(this->start);
memory_mark(this->labels);
}
/**
* Perform garbage collection on a live object.
*
* @param liveMark The current live mark.
*/
void RexxInstructionMessage::live(size_t liveMark)
{
// must be first object marked
memory_mark(nextInstruction);
memory_mark(name);
memory_mark(target);
memory_mark(super);
memory_mark_array(argumentCount, arguments);
}
void RexxSupplier::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->values);
memory_mark(this->indexes);
memory_mark(this->objectVariables);
}
void RexxBehaviour::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->methodDictionary);
memory_mark(this->instanceMethodDictionary);
memory_mark(this->scopes);
memory_mark(this->owningClass);
}
void RexxInstructionAddress::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(this->nextInstruction); /* must be first one marked */
memory_mark(this->expression);
memory_mark(this->environment);
memory_mark(this->command);
}
/**
* Perform garbage collection on a live object.
*
* @param liveMark The current live mark.
*/
void RexxInstructionDoCount::live(size_t liveMark)
{
// must be first object marked
memory_mark(nextInstruction);
memory_mark(end);
memory_mark(label);
// helpers for additional types of loops handle marking here
forLoop.live(liveMark);
}
/**
* Perform garbage collection on a live object.
*
* @param liveMark The current live mark.
*/
void RexxInstructionControlledDo::live(size_t liveMark)
{
// must be first object marked
memory_mark(nextInstruction);
memory_mark(end);
memory_mark(label);
memory_mark(countVariable);
// helpers for additional types of loops handle marking here
controlLoop.live(liveMark);
}
void RexxInstructionDrop::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
size_t i; /* loop counter */
size_t count; /* argument count */
memory_mark(this->nextInstruction); /* must be first one marked */
for (i = 0, count = variableCount; i < count; i++)
{
memory_mark(this->variables[i]);
}
}
void ActivityManager::live(size_t liveMark)
/******************************************************************************/
/* NOTE: we do not mark the UninitTables. MEMORY will request the table */
/* and mark it for us. This is so that it can determine if there are */
/* any objects that a "dead" and need uninit run. Activity will run the */
/* UNINIT, but we let Garbage Collection, handle detection/etc. */
/* NOTE: we also do not mark the subClasses table. This will be managed */
/* by memory so that we can reclaim classes once all of the instances have */
/* also been reclaimed. */
/******************************************************************************/
{
memory_mark(availableActivities);
memory_mark(allActivities);
}
void InterpreterInstance::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
memory_mark(rootActivity);
memory_mark(allActivities);
memory_mark(globalReferences);
memory_mark(defaultEnvironment);
memory_mark(searchPath);
memory_mark(searchExtensions);
memory_mark(securityManager);
memory_mark(localEnvironment);
memory_mark(commandHandlers);
memory_mark(requiresFiles);
}
/**
* Normal garbage collection live marking
*
* @param liveMark The current live mark.
*/
void ListContents::live(size_t liveMark)
{
// we only mark the active items rather than scanning the entire content area.
for (size_t position = firstItem; position != NoMore; position = nextEntry(position))
{
memory_mark(entries[position].value);
}
}
void RexxListTable::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
for (size_t index = 0; index < this->size; index++)
{
/* mark an element */
memory_mark(this->elements[index].value);
}
}
void RexxStack::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/******************************************************************************/
{
RexxObject **rp;
for (rp = this->stack; rp < this->stack+this->stackSize(); rp++)
{
memory_mark(*rp);
}
}
void RexxInstructionForward::live(size_t liveMark)
/******************************************************************************/
/* Function: Process live calls */
/******************************************************************************/
{
memory_mark(this->nextInstruction); /* must be first one marked */
memory_mark(this->target);
memory_mark(this->message);
memory_mark(this->superClass);
memory_mark(this->arguments);
memory_mark(this->array);
}
void RexxEnvelope::live(size_t liveMark)
/******************************************************************************/
/* Function: Normal garbage collection live marking */
/* */
/* NOTE: Do not mark flattenStack */
/******************************************************************************/
{
memory_mark(this->home);
memory_mark(this->receiver);
memory_mark(this->duptable);
memory_mark(this->savetable);
memory_mark(this->buffer);
memory_mark(this->rehashtable);
}
/**
* Normal garbage collection live marking
*
* @param liveMark The current live mark.
*/
void PointerTable::live(size_t liveMark)
{
memory_mark(contents);
}
void SupplierClass::live(size_t liveMark)
{
memory_mark(items);
memory_mark(indexes);
memory_mark(objectVariables);
}
/**
* Perform garbage collection on a live object.
*
* @param liveMark The current live mark.
*/
void RexxVariable::live(size_t liveMark)
{
memory_mark(variableValue);
memory_mark(variableName);
memory_mark(dependents);
}
virtual void mark(size_t liveMark) { memory_mark(protectedObject); }
/**
* Normal garbage collection live marking
*
* @param liveMark The current live mark.
*/
void MapTable::live(size_t liveMark)
{
memory_mark(contents);
}
