/**
* Flatten the table contents as part of a saved program.
*
* @param envelope The envelope we're flattening into.
*/
void AttributeGetterCode::flatten(Envelope *envelope)
{
setUpFlatten(AttributeGetterCode)
flattenRef(attribute);
cleanUpFlatten
}
/**
* Flatten the table contents as part of a saved program.
*
* @param envelope The envelope we're flattening into.
*/
void DelegateCode::flatten(Envelope *envelope)
{
setUpFlatten(DelegateCode)
flattenRef(attribute);
cleanUpFlatten
}
/**
* Flatten the table contents as part of a saved program.
*
* @param envelope The envelope we're flattening into.
*/
void ConstantGetterCode::flatten(Envelope *envelope)
{
setUpFlatten(ConstantGetterCode)
flattenRef(constantValue);
cleanUpFlatten
}
/**
* Flatten the directive instance.
*
* @param envelope The envelope we're flattening into.
*/
void RequiresDirective::flatten(RexxEnvelope *envelope)
{
setUpFlatten(RequiresDirective)
flatten_reference(newThis->nextInstruction, envelope);
flatten_reference(newThis->name, envelope);
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void RexxInstructionThen::flatten(Envelope *envelope)
{
setUpFlatten(RexxInstructionThen)
flattenRef(nextInstruction);
flattenRef(parent);
cleanUpFlatten
}
void SupplierClass::flatten(Envelope *envelope)
{
setUpFlatten(SupplierClass)
flattenRef(items);
flattenRef(indexes);
flattenRef(objectVariables);
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void RexxInstructionIf::flatten(Envelope *envelope)
{
setUpFlatten(RexxInstructionIf)
flattenRef(nextInstruction);
flattenRef(condition);
flattenRef(else_location);
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void RexxVariable::flatten(Envelope *envelope)
{
setUpFlatten(RexxVariable)
flattenRef(variableValue);
flattenRef(variableName);
flattenRef(dependents);
cleanUpFlatten
}
/**
* Flatten the table contents as part of a saved program.
*
* @param envelope The envelope we're flattening into.
*/
void DirectoryClass::flatten(Envelope *envelope)
{
setUpFlatten(DirectoryClass)
flattenRef(contents);
flattenRef(methodTable);
flattenRef(unknownMethod);
flattenRef(objectVariables);
cleanUpFlatten
}
void RexxInstruction::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxInstruction)
flatten_reference(newThis->nextInstruction, envelope);
cleanUpFlatten
}
/**
* Flatten the table contents as part of a saved program.
*
* @param envelope The envelope we're flattening into.
*/
void StemClass::flatten(Envelope *envelope)
{
setUpFlatten(StemClass)
flattenRef(value);
flattenRef(stemName);
flattenRef(objectVariables);
flattenCompoundTable();
cleanUpFlatten
}
void RexxHashTableCollection::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxHashTableCollection)
flatten_reference(newThis->contents, envelope);
flatten_reference(newThis->objectVariables, envelope);
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void MethodClass::flatten(Envelope *envelope)
{
setUpFlatten(MethodClass)
flattenRef(scope);
flattenRef(code);
flattenRef(executableName);
flattenRef(objectVariables);
flattenRef(annotations);
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void RexxInstructionMessage::flatten(Envelope *envelope)
{
setUpFlatten(RexxInstructionMessage)
flattenRef(nextInstruction);
flattenRef(name);
flattenRef(target);
flattenRef(super);
flattenArrayRefs(argumentCount, arguments);
cleanUpFlatten
}
void RexxSupplier::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxSupplier)
flatten_reference(newThis->values, envelope);
flatten_reference(newThis->indexes, envelope);
cleanUpFlatten
}
void RexxCode::flatten(RexxEnvelope * envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxCode)
flatten_reference(newThis->source, envelope);
flatten_reference(newThis->start, envelope);
flatten_reference(newThis->labels, envelope);
cleanUpFlatten
}
void RexxVariable::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxVariable)
flatten_reference(newThis->variableValue, envelope);
flatten_reference(newThis->variable_name, envelope);
flatten_reference(newThis->dependents, envelope);
cleanUpFlatten
}
void RexxInstructionAddress::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxInstructionAddress)
flatten_reference(newThis->nextInstruction, envelope);
flatten_reference(newThis->expression, envelope);
flatten_reference(newThis->environment, envelope);
flatten_reference(newThis->command, envelope);
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void RexxInstructionDoCount::flatten(Envelope *envelope)
{
setUpFlatten(RexxInstructionDoCount)
flattenRef(nextInstruction);
flattenRef(end);
flattenRef(label);
// flatten is a bit of a pain with embedded objects because
// everything depends on having correct pointers to object references in
// the copied buffer. We need to directly reference all of the elements here.
flattenRef(forLoop.forCount);
cleanUpFlatten
}
void RexxInstructionForward::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an instruction object */
/******************************************************************************/
{
setUpFlatten(RexxInstructionForward)
flatten_reference(newThis->nextInstruction, envelope);
flatten_reference(newThis->target, envelope);
flatten_reference(newThis->message, envelope);
flatten_reference(newThis->superClass, envelope);
flatten_reference(newThis->arguments, envelope);
flatten_reference(newThis->array, envelope);
cleanUpFlatten
}
void RexxInstructionDrop::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
size_t i; /* loop counter */
size_t count; /* argument count */
setUpFlatten(RexxInstructionDrop)
flatten_reference(newThis->nextInstruction, envelope);
for (i = 0, count = variableCount; i < count; i++)
{
flatten_reference(newThis->variables[i], envelope);
}
cleanUpFlatten
}
void RexxBehaviour::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function: Flatten an object */
/******************************************************************************/
{
setUpFlatten(RexxBehaviour)
flatten_reference(newThis->methodDictionary, envelope);
flatten_reference(newThis->instanceMethodDictionary, envelope);
flatten_reference(newThis->scopes, envelope);
flatten_reference(newThis->owningClass, envelope);
/* Is this a non-primitive behav */
if (this->isNonPrimitive())
{
/* yes, mark that we need to be */
/* resolved on the puff. */
newThis->setNotResolved();
}
cleanUpFlatten
}
/**
* Flatten a source object.
*
* @param envelope The envelope that will hold the flattened object.
*/
void RexxInstructionControlledDoUntil::flatten(Envelope *envelope)
{
setUpFlatten(RexxInstructionControlledDoUntil)
flattenRef(nextInstruction);
flattenRef(end);
flattenRef(label);
flattenRef(countVariable);
// flatten is a bit of a pain with embedded objects because
// everything depends on having correct pointers to object references in
// the copied buffer. We need to directly reference all of the elements here.
flattenRef(controlLoop.initial);
flattenRef(controlLoop.to);
flattenRef(controlLoop.by);
flattenRef(controlLoop.forCount);
flattenRef(controlLoop.control);
flattenRef(whileLoop.conditional);
cleanUpFlatten
}
