/***************************************************
NAME : BsaveClassLinks
DESCRIPTION : Writes class links binary data
INPUTS : 1) The defclass
2) The binary file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defclass links binary data written
NOTES : None
***************************************************/
static void BsaveClassLinks(
struct constructHeader *theDefclass,
void *buf)
{
DEFCLASS *cls = (DEFCLASS *) theDefclass;
register unsigned i;
long dummy_class_index;
for (i = 0 ; i < cls->directSuperclasses.classCount ; i++)
{
dummy_class_index = DefclassIndex(cls->directSuperclasses.classArray[i]);
GenWrite((void *) &dummy_class_index,(UNLN) sizeof(long),(FILE *) buf);
}
LinkCount += cls->directSuperclasses.classCount;
for (i = 0 ; i < cls->directSubclasses.classCount ; i++)
{
dummy_class_index = DefclassIndex(cls->directSubclasses.classArray[i]);
GenWrite((void *) &dummy_class_index,(UNLN) sizeof(long),(FILE *) buf);
}
LinkCount += cls->directSubclasses.classCount;
for (i = 0 ; i < cls->allSuperclasses.classCount ; i++)
{
dummy_class_index = DefclassIndex(cls->allSuperclasses.classArray[i]);
GenWrite((void *) &dummy_class_index,(UNLN) sizeof(long),(FILE *) buf);
}
LinkCount += cls->allSuperclasses.classCount;
}
/*************************************************************
NAME : BsaveRestrictionTypes
DESCRIPTION : Bsaves defgeneric methods' retrictions' types
INPUTS : 1) The defgeneric
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defgeneric methods' restrictions' types saved
NOTES : None
*************************************************************/
static void BsaveRestrictionTypes(
struct constructHeader *theDefgeneric,
void *userBuffer)
{
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
long dummy_type;
RESTRICTION *rptr;
register unsigned i,j,k;
for (i = 0 ; i < gfunc->mcnt ; i++)
{
for (j = 0 ; j < gfunc->methods[i].restrictionCount ; j++)
{
rptr = &gfunc->methods[i].restrictions[j];
for (k = 0 ; k < rptr->tcnt ; k++)
{
#if OBJECT_SYSTEM
dummy_type = DefclassIndex(rptr->types[k]);
#else
dummy_type = (long) ((INTEGER_HN *) rptr->types[k])->contents;
#endif
GenWrite(&dummy_type,(unsigned long) sizeof(long),(FILE *) userBuffer);
}
}
}
}
static void BsaveRestrictionTypes(
void *theEnv,
struct constructHeader *theDefgeneric,
void *userBuffer)
{
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
long dummy_type;
RESTRICTION *rptr;
short i,j,k;
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(theEnv)
#endif
for (i = 0 ; i < gfunc->mcnt ; i++)
{
for (j = 0 ; j < gfunc->methods[i].restrictionCount ; j++)
{
rptr = &gfunc->methods[i].restrictions[j];
for (k = 0 ; k < rptr->tcnt ; k++)
{
#if OBJECT_SYSTEM
dummy_type = DefclassIndex(rptr->types[k]);
#else
dummy_type = (long) ((INTEGER_HN *) rptr->types[k])->contents;
#endif
GenWrite(&dummy_type,sizeof(long),(FILE *) userBuffer);
}
}
}
}
/************************************************************
NAME : BsaveHandlers
DESCRIPTION : Writes class message-handlers binary data
INPUTS : 1) The defclass
2) The binary file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defclass message-handler binary data written
NOTES : None
************************************************************/
static void BsaveHandlers(
struct constructHeader *theDefclass,
void *buf)
{
DEFCLASS *cls = (DEFCLASS *) theDefclass;
register unsigned i;
BSAVE_HANDLER dummy_handler;
HANDLER *hnd;
for (i = 0 ; i < cls->handlerCount ; i++)
{
hnd = &cls->handlers[i];
dummy_handler.system = hnd->system;
dummy_handler.type = hnd->type;
dummy_handler.minParams = hnd->minParams;
dummy_handler.maxParams = hnd->maxParams;
dummy_handler.localVarCount = hnd->localVarCount;
dummy_handler.cls = DefclassIndex(hnd->cls);
dummy_handler.name = (long) hnd->name->bucket;
if (hnd->actions != NULL)
{
dummy_handler.actions = ExpressionCount;
ExpressionCount += ExpressionSize(hnd->actions);
}
else
dummy_handler.actions = -1L;
GenWrite((void *) &dummy_handler,(UNLN) sizeof(BSAVE_HANDLER),(FILE *) buf);
}
}
/***************************************************
NAME : BsaveSlots
DESCRIPTION : Writes class slots binary data
INPUTS : 1) The defclass
2) The binary file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defclass slots binary data written
NOTES : None
***************************************************/
static void BsaveSlots(
struct constructHeader *theDefclass,
void *buf)
{
DEFCLASS *cls = (DEFCLASS *) theDefclass;
register unsigned i;
BSAVE_SLOT_DESC dummy_slot;
SLOT_DESC *sp;
EXPRESSION *tmpexp;
for (i = 0 ; i < cls->slotCount ; i++)
{
sp = &cls->slots[i];
dummy_slot.dynamicDefault = sp->dynamicDefault;
dummy_slot.noDefault = sp->noDefault;
dummy_slot.shared = sp->shared;
dummy_slot.multiple = sp->multiple;
dummy_slot.composite = sp->composite;
dummy_slot.noInherit = sp->noInherit;
dummy_slot.noWrite = sp->noWrite;
dummy_slot.initializeOnly = sp->initializeOnly;
dummy_slot.reactive = sp->reactive;
dummy_slot.publicVisibility = sp->publicVisibility;
dummy_slot.createReadAccessor = sp->createReadAccessor;
dummy_slot.createWriteAccessor = sp->createWriteAccessor;
dummy_slot.cls = DefclassIndex(sp->cls);
dummy_slot.slotName = SlotNameIndex(sp->slotName);
dummy_slot.overrideMessage = (long) sp->overrideMessage->bucket;
if (sp->defaultValue != NULL)
{
dummy_slot.defaultValue = ExpressionCount;
if (sp->dynamicDefault)
ExpressionCount += ExpressionSize((EXPRESSION *) sp->defaultValue);
else
{
tmpexp = ConvertValueToExpression((DATA_OBJECT *) sp->defaultValue);
ExpressionCount += ExpressionSize(tmpexp);
ReturnExpression(tmpexp);
}
}
else
dummy_slot.defaultValue = -1L;
dummy_slot.constraint = ConstraintIndex(sp->constraint);
GenWrite((void *) &dummy_slot,(UNLN) sizeof(BSAVE_SLOT_DESC),(FILE *) buf);
}
}
