/*-------------------------------------------------------------------------*/
void
struct_free (struct_t *pStruct)
/* Free the struct <pStruct> and all referenced data.
*/
{
unsigned short num;
struct_type_t * pSType;
#ifdef DEBUG
if (!pStruct)
fatal("NULL pointer passed to struct_free().\n");
if (!pStruct->user)
fatal("No wizlist pointer for struct in struct_free().");
if (pStruct->ref != 0)
fatal("Struct with %"PRIdPINT" refs passed to struct_free().\n"
, pStruct->ref);
#endif
for (num = struct_size(pStruct); num-- > 0; )
{
free_svalue(&pStruct->member[num]);
}
pSType = pStruct->type;
struct_free_empty(pStruct); /* needs a valid .type */
free_struct_type(pSType);
} /* struct_free() */
/*-------------------------------------------------------------------------*/
void
_free_lpctype (lpctype_t *t)
/* Deallocate the vector <p>, properly freeing the contained elements.
*/
{
/* There can't be any arrays of us,
* otherwise our refcount wouldn't be 0.
*/
assert(t->array_of == NULL);
/* Same for unions. */
assert(t->unions_of == NULL);
switch(t->t_class)
{
case TCLASS_PRIMARY:
break; /* Nothing to do. */
case TCLASS_STRUCT:
if (t->t_struct)
{
t->t_struct->lpctype = NULL;
free_struct_type(t->t_struct);
}
break;
case TCLASS_ARRAY:
t->t_array.element->array_of = NULL;
free_lpctype(t->t_array.element);
break;
case TCLASS_UNION:
{
/* Remove this union from the union list of .head. */
lpctype_t **ptr = &(t->t_union.head->unions_of);
while(*ptr && *ptr != t)
ptr = &((*ptr)->t_union.next);
assert(ptr != NULL);
*ptr = t->t_union.next;
}
free_lpctype(t->t_union.member);
free_lpctype(t->t_union.head);
break;
}
xfree(t);
} /* _free_lpctype() */
/*-------------------------------------------------------------------------*/
void
struct_free_type (struct_type_t *pSType)
/* Free the struct typeobject <pSType> and all referenced data.
*/
{
unsigned short num;
#ifdef DEBUG
if (!pSType)
fatal("NULL pointer passed to struct_free_type().\n");
if (pSType->ref != 0)
fatal("struct typeobject with %"PRIdPINT" refs passed to struct_free_type().\n"
, pSType->ref);
#endif
num_struct_type--;
size_struct_type -= STRUCT_TYPE_MEMSIZE
+ STRUCT_TYPE_MEMBER_MEMSIZE(pSType->num_members);
if(pSType->name->current == pSType)
pSType->name->current = NULL;
free_struct_name(pSType->name);
if (pSType->unique_name)
free_mstring(pSType->unique_name);
if (pSType->base)
free_struct_type(pSType->base);
for (num = 0; num < pSType->num_members; num++)
{
free_struct_member_data(&pSType->member[num]);
}
if (pSType->member)
xfree(pSType->member);
xfree(pSType);
} /* struct_free_type() */
/*-------------------------------------------------------------------------*/
struct_t *
struct_new_anonymous (int num_members)
/* Create an empty anonymous struct instance with <num_members>
* and return its pointer.
* Return NULL when out of memory.
*
* The returned struct will have one reference.
*/
{
struct_type_t * pType;
struct_t * pStruct;
int i;
char buf[100];
Bool gotError;
(void) ref_mstring(STR_ANONYMOUS);
(void) ref_mstring(STR_ANONYMOUS);
pType = struct_new_type( STR_ANONYMOUS
, STR_ANONYMOUS
, 0
, NULL, num_members, NULL);
if (pType == NULL)
return NULL;
pStruct = struct_new(pType);
free_struct_type(pType);
/* struct_new() added one ref, but since this is an anonymous
* struct, the struct instance will hold the only ref.
*/
if (pStruct == NULL)
{
// the type was not referenced by struct_new() in this case, so it must
// not be freed.
return NULL;
}
/* Create default members */
gotError = MY_FALSE;
for (i = 0; i < num_members; i++)
{
sprintf(buf, "m-%d", i);
pType->member[i].name = new_tabled(buf);
if (!pType->member[i].name)
{
debug_message("(%s:%d) Out of memory (%zu bytes) for member name\n"
, __FILE__, __LINE__, strlen(buf)
);
gotError = MY_TRUE;
break;
}
pType->member[i].type = lpctype_mixed;
}
if (gotError)
{
free_struct(pStruct);
pStruct = NULL;
}
return pStruct;
} /* struct_new_anonymous() */
/*-------------------------------------------------------------------------*/
struct_type_t *
struct_fill_prototype ( struct_type_t *type
, int32 prog_id
, struct_type_t *base
, int num_members
, struct_member_t *member)
/* Complete the struct prototype <type> with the given data and return
* its pointer. If <member> is NULL, the member entries are left empty.
* The references from the data are adopted, and the result is the
* new typeobject with one reference.
* When an error occurs, NULL is returned and the input data is freed,
* including the prototype.
*/
{
struct_member_t * pMembers;
unsigned short num;
#ifdef DEBUG
if (type == NULL)
fatal("NULL typeobject pointer passed to struct_fill_prototype().\n");
if (type->prog_id != 0)
fatal("Non-prototype typeobject passed to struct_fill_prototype().\n");
#endif
if (num_members != 0)
pMembers = xalloc(STRUCT_TYPE_MEMBER_MEMSIZE(num_members));
else
pMembers = NULL;
if (num_members == 0 || pMembers != NULL)
{
type->prog_id = prog_id;
type->base = base;
type->num_members = num_members;
if (member != NULL)
{
for (num = 0; num < num_members; num++)
{
pMembers[num] = member[num];
}
}
else
memset(pMembers, 0, STRUCT_TYPE_MEMBER_MEMSIZE(num_members));
type->member = pMembers;
size_struct_type += STRUCT_TYPE_MEMBER_MEMSIZE(num_members);
}
else
{
free_struct_name(type->name);
if (base)
free_struct_type(base);
if (member != NULL)
{
for (num = 0; num < num_members; num++)
{
free_struct_member_data(&member[num]);
}
}
xfree(type);
num_struct_type--;
size_struct_type -= STRUCT_TYPE_MEMSIZE;
}
return type;
} /* struct_fill_prototype() */
