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