/** * 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); }