void hkl_string_free(HklString* string)
{
assert(string != NULL);
hkl_string_clear(string);
hkl_free_object(string);
}
void hklr_statement_free(HklrStatement* stmt)
{
assert(stmt != NULL);
switch (stmt->type)
{
case HKL_STMT_PUTS:
// Free the expression
hklr_expression_free(stmt->arg[0].expression);
break;
case HKL_STMT_INIT:
hklr_expression_free(stmt->arg[2].expression);
break;
case HKL_STMT_ASSIGN:
hklr_expression_free(stmt->arg[0].expression);
hklr_expression_free(stmt->arg[1].expression);
break;
case HKL_STMT_IF:
case HKL_STMT_WHILE:
hklr_expression_free(stmt->arg[0].expression);
hkl_list_traverse(stmt->arg[1].list, hklr_statement_free_list, NULL);
hkl_list_free(stmt->arg[1].list);
break;
default:
break;
}
hkl_free_object(stmt);
}
void hkl_deque_free(HklDeque* deque)
{
assert(deque != NULL);
hkl_deque_clear(deque);
hkl_free_object(deque);
}
void hkl_list_free(HklList* list)
{
assert(list != NULL);
hkl_list_clear(list);
hkl_free_object(list);
}
void hkl_hash_free(HklHash* hash)
{
assert(hash != NULL);
hkl_hash_clear(hash);
// Free the buckets
free(hash->buckets);
hkl_free_object(hash);
}
void hklr_function_free(HklrFunction* function)
{
hkl_list_traverse(function->stmt_list, free_statements, NULL);
hkl_list_free(function->stmt_list);
hkl_list_traverse(function->args_list, free_names, NULL);
hkl_list_free(function->args_list);
hkl_tree_traverse(function->closure_list, dec_closures, NULL);
hkl_tree_free(function->closure_list);
hkl_free_object(function);
}
static void hkl_treenode_free(HklTreeNode* node)
{
assert(node != NULL);
if (node->left != NULL)
hkl_treenode_free(node->left);
if (node->right != NULL)
hkl_treenode_free(node->right);
hkl_pair_free(node->pair);
hkl_free_object(node);
}
void hklr_scope_pop()
{
HklScope* scope = hkl_list_pop_back(HKLR.scopes);
// decrement all the locals
hkl_hash_traverse(scope->locals, hklr_gc_dec_hash, NULL);
// dont dec upvals as they arent in our scope
// hkl_hash_traverse(scope->upvals, hklr_gc_dec_hash, NULL);
hkl_hash_free(scope->locals);
hkl_hash_free(scope->upvals);
hkl_free_object(scope);
}
void hkl_value_free(HklValue* value)
{
assert(value != NULL);
switch (value->type)
{
case HKL_TYPE_STRING:
hkl_string_free(value->as.string);
break;
default:
break;
}
hkl_free_object(value);
}
void hklr_scope_pop()
{
HklScope* scope = HKLR.scopes;
HKLR.scopes = scope->prev;
HKLR.scope_level--;
// decrement all the locals
hkl_hash_traverse(scope->locals, hklr_gc_dec_hash, NULL);
// dont dec upvals as they arent in our scope
// hkl_hash_traverse(scope->upvals, hklr_gc_dec_hash, NULL);
hkl_hash_free(scope->locals);
hkl_hash_free(scope->upvals);
hkl_free_object(scope);
}
void hklr_object_free(HklrObject* object)
{
assert(object != NULL);
switch (object->type)
{
case HKL_TYPE_STRING:
hkl_string_free(object->as.string);
break;
default:
break;
}
hkl_free_object(object);
}
void hkl_expression_free(HklExpression* expr)
{
assert(expr != NULL);
switch (expr->type)
{
case HKL_EXPR_STRING:
// free the internal string
hkl_string_free(expr->arg[0].string);
break;
default:
break;
}
hkl_free_object(expr);
}
void hklr_expression_free(HklrExpression* expr)
{
assert(expr != NULL);
switch (expr->type)
{
case HKL_EXPR_STRING:
// free the internal string
hkl_string_free(expr->arg[0].string);
break;
case HKL_EXPR_UNARY:
hklr_expression_free(expr->arg[1].expression);
break;
case HKL_EXPR_BINARY:
hklr_expression_free(expr->arg[0].expression);
hklr_expression_free(expr->arg[2].expression);
break;
case HKL_EXPR_VAR:
hkl_string_free(expr->arg[0].string);
hkl_list_traverse(expr->arg[1].list, hklr_var_free_list, NULL);
hkl_list_free(expr->arg[1].list);
break;
case HKL_EXPR_ARRAY:
hkl_list_traverse(expr->arg[0].list, hklr_array_free_list, NULL);
hkl_list_free(expr->arg[0].list);
break;
case HKL_EXPR_HASH:
hkl_list_traverse(expr->arg[0].list, hklr_hash_free_list, NULL);
hkl_list_free(expr->arg[0].list);
break;
default:
break;
}
hkl_free_object(expr);
}
void hkl_tree_free(HklTree* tree)
{
hkl_tree_clear(tree);
hkl_free_object(tree);
}
static void hkl_listnode_free(HklListNode* node)
{
assert(node != NULL);
hkl_free_object(node);
}
static void hkl_dequenode_free(HklDequeNode* node)
{
assert(node != NULL);
hkl_free_object(node);
}
void hkl_pair_free(HklPair* pair)
{
hkl_string_free(pair->key);
hkl_free_object(pair);
}
