void mio_close(MFP* mfp)
{
assert(mfp_is_valid(mfp));
switch(mfp->type)
{
case MFP_STRG :
break;
case MFP_FILE :
fclose(mfp->fp.file);
break;
case MFP_PIPE :
pclose(mfp->fp.file);
break;
#ifndef WITHOUT_ZLIB
case MFP_ZLIB :
gzclose(mfp->fp.zlib);
break;
#endif /* ! WITHOUT_ZLIB */
default :
abort();
}
SID_del(mfp);
free(mfp);
}
void symbol_exit(void)
{
Symbol* q;
Symbol* p;
int i;
for(p = anchor; p != NULL; p = q)
{
assert(symbol_is_valid(p));
SID_del(p);
q = p->next;
for(i = 0; i < p->used; i++)
entry_free(p->entry[i]);
free(p->entry);
set_free(p->set);
hash_free(p->hash);
if (p->deflt != NULL)
entry_free(p->deflt);
free(p);
}
anchor = NULL;
}
void rpar_free(RPar* rpar)
{
assert(rpar_is_valid(rpar));
SID_del(rpar);
free(rpar);
}
void stmt_free(Stmt* stmt)
{
assert(stmt_is_valid(stmt));
SID_del(stmt);
if (stmt->node != NULL)
code_free(stmt->node);
free((void*)stmt->filename);
free((void*)stmt->text);
free(stmt);
}
void rdef_free(RDef* rdef)
{
assert(rdef_is_valid(rdef));
rdef->refc--;
if (rdef->refc == 0)
{
SID_del(rdef);
free(rdef);
}
}
void define_exit(void)
{
Define* q;
Define* p;
for(p = anchor.next; p != NULL; p = q)
{
assert(define_is_valid(p));
SID_del(p);
tuple_free(p->param);
q = p->next;
free(p);
}
anchor.next = NULL;
}
void list_free(List* list)
{
ListElem* p;
ListElem* q;
assert(list_is_valid(list));
list->refc--;
if (list->refc == 0)
{
SID_del(list);
for(p = list->anchor.next; p != &list->anchor; p = q)
{
q = p->next;
switch(list->type)
{
case LIST_ELEM :
elem_free(p->data.elem);
break;
case LIST_TUPLE :
tuple_free(p->data.tuple);
break;
case LIST_ENTRY :
entry_free(p->data.entry);
break;
case LIST_IDXELEM :
break;
case LIST_LIST :
list_free(p->data.list);
break;
default :
abort();
}
blk_free(p, sizeof(*p));
}
free(list);
}
}
void mio_exit()
{
StrgFile* p;
StrgFile* q;
for(p = strg_file_root; p != NULL; p = q)
{
q = p->next;
assert(strgfile_is_valid(p));
free((void*)p->name);
if (p->use_copy)
free((void*)p->content);
SID_del(p);
free(p);
}
strg_file_root = NULL;
}
void hash_free(Hash* hash)
{
HElem* he;
HElem* hq;
unsigned int i;
assert(hash_is_valid(hash));
if (verbose >= VERB_CHATTER)
hash_statist(stderr, hash);
SID_del(hash);
for(i = 0; i < hash->size; i++)
{
for(he = hash->bucket[i]; he != NULL; he = hq)
{
hq = he->next;
blk_free(he, sizeof(*he));
}
}
free(hash->bucket);
free(hash);
}
