void Parser::FNSyntax_DeleteExpression(ExprNode *node)
{
    ExprNode *temp = NULL;

    for(ExprNode *i = node; i != NULL; i = i->next)
    {
        if(temp != NULL)
        {
            POV_FREE(temp);
        }

        FNSyntax_DeleteExpression(i->child);

        if((i->op == OP_VARIABLE) || (i->op == OP_MEMBER))
        {
            POV_FREE(i->variable);
        }
        else if(i->op == OP_CALL)
        {
            if((i->call.token == FUNCT_ID_TOKEN) || (i->call.token == VECTFUNCT_ID_TOKEN))
                dynamic_cast<FunctionVM*>(sceneData->functionContextFactory)->RemoveFunction(i->call.fn);
            POV_FREE(i->call.name);
        }

        temp = i;
    }

    if(temp != NULL)
    {
        POV_FREE(temp);
    }
}

void FNSyntax_DeleteExpression(ExprNode *node)
{
	ExprNode *temp = NULL;

	for(ExprNode *i = node; i != NULL; i = i->next)
	{
		if(temp != NULL)
		{
			POV_FREE(temp);
		}

		FNSyntax_DeleteExpression(i->child);

		if((i->op == OP_VARIABLE) || (i->op == OP_MEMBER))
		{
			POV_FREE(i->variable);
		}
		else if(i->op == OP_CALL)
		{
			if((i->call.token == FUNCT_ID_TOKEN) || (i->call.token == VECTFUNCT_ID_TOKEN))
				POVFPU_RemoveFunction(i->call.fn);
			POV_FREE(i->call.name);
		}

		temp = i;
	}

	if(temp != NULL)
	{
		POV_FREE(temp);
	}
}

void BicubicPatch::bezier_tree_deleter(BEZIER_NODE *Node)
{
    int i;
    BEZIER_CHILDREN *Children;

    /* If this is an interior node then continue the descent. */

    if (Node->Node_Type == BEZIER_INTERIOR_NODE)
    {
        Children = reinterpret_cast<BEZIER_CHILDREN *>(Node->Data_Ptr);

        for (i = 0; i < Node->Count; i++)
        {
            bezier_tree_deleter(Children->Children[i]);
        }

        POV_FREE(Children);
    }
    else
    {
        if (Node->Node_Type == BEZIER_LEAF_NODE)
        {
            /* Free the memory used for the vertices. */

            POV_FREE(Node->Data_Ptr);
        }
    }

    /* Free the memory used for the node. */

    POV_FREE(Node);
}

void Destroy_Priority_Queue(PRIORITY_QUEUE *Queue)
{
  if (Queue != NULL)
  {
    POV_FREE(Queue->Queue);

    POV_FREE(Queue);
  }
}

static void cleanup_gif_decoder ()
{
  POV_FREE (dstack);
  POV_FREE (suffix);
  POV_FREE (prefix);

  dstack = NULL;
  suffix = NULL;
  prefix = NULL;
}

Polygon::~Polygon()
{
    if (--(Data->References) == 0)
    {
        POV_FREE (Data->Points);

        POV_FREE (Data);
    }

    Destroy_Transform(Trans);
}

void Destroy_Spline(SPLINE * Spline)
{
    if (Spline->ref_count <= 0)
        throw POV_EXCEPTION_STRING("Internal error: Invalid spline reference count\n");

    Spline->ref_count --;
    if (Spline->ref_count == 0)
    {
        POV_FREE(Spline->SplineEntries);
        POV_FREE(Spline);
    }
}

Lathe::~Lathe()
{
    Destroy_Transform(Trans);

    if (--(Spline->References) == 0)
    {
        Destroy_BCyl(Spline->BCyl);

        POV_FREE(Spline->Entry);

        POV_FREE(Spline);
    }
}

TraceThreadData::~TraceThreadData()
{
    delete functionContext;
    for(vector<GenericFunctionContextPtr>::iterator i = functionPatternContext.begin(); i != functionPatternContext.end(); ++i)
        delete *i;

    POV_FREE(Blob_Coefficients);
    POV_FREE(Blob_Queue);
    POV_FREE(isosurfaceData);
    Fractal::Free_Iteration_Stack(Fractal_IStack);
    delete surfacePhotonMap;
    delete mediaPhotonMap;
    delete[] Blob_Intervals;
    for(vector<LightSource *>::iterator it = lightSources.begin(); it != lightSources.end(); it++)
        Destroy_Object(*it);
}

UCS2 *Parser::Parse_Substr(bool pathname)
{
	UCS2 *str;
	UCS2 *New;
	int l, d;

	GET(LEFT_PAREN_TOKEN);

	str = Parse_String(pathname);
	Parse_Comma();
	l = (int)Parse_Float();
	Parse_Comma();
	d = (int)Parse_Float();

	GET(RIGHT_PAREN_TOKEN);

	if(((l + d - 1) > UCS2_strlen(str)) || (l < 0) || (d < 0))
		Error("Illegal parameters in substr.");

	New = reinterpret_cast<UCS2 *>(POV_MALLOC(sizeof(UCS2) * (d + 1), "temporary string"));
	UCS2_strncpy(New, &(str[l - 1]), d);
	New[d] = 0;

	POV_FREE(str);

	return New;
}

IsoSurface::~IsoSurface()
{
    if(--mginfo->refcnt == 0)
        POV_FREE(mginfo);
    delete Function;
    Destroy_Transform(Trans);
}

std::string Parser::Parse_SysString(bool pathname, bool require)
{
    UCS2 *cstr = Parse_String(pathname, require);
    std::string ret(UCS2toSysString(cstr));
    POV_FREE(cstr);
    return ret;
}

void Parser::Destroy_Function(FUNCTION_PTR Function)
{
	if(Function != NULL)
	{
		sceneData->functionVM->RemoveFunction(*Function);
		POV_FREE(Function);
	}
}

void Deinitialize_VLBuffer_Code()
{
  if (Node_Queue != NULL)
{
    POV_FREE(Node_Queue->Queue);

    POV_FREE(Node_Queue);
  }

  if (VLBuffer_Queue != NULL)
  {
    Destroy_Priority_Queue(VLBuffer_Queue);
  }

  Node_Queue     = NULL;
  VLBuffer_Queue = NULL;
}

void Parametric::Destroy_PrecompParVal()
{
	if (PData == NULL)
		return;

	PData->use--;
	if (PData->use == 0)
	{
		if (PData->flags & OK_X)
		{
			POV_FREE(PData->Low[0]);
			POV_FREE(PData->Hi[0]);
		}
		if (PData->flags & OK_Y)
		{
			POV_FREE(PData->Low[1]);
			POV_FREE(PData->Hi[1]);
		}
		if (PData->flags & OK_Z)
		{
			POV_FREE(PData->Low[2]);
			POV_FREE(PData->Hi[2]);
		}
		POV_FREE(PData);
	}
}

void Destroy_Tnormal(TNORMAL *Tnormal)
{
	if (Tnormal != NULL)
	{
		Destroy_TPat_Fields ((TPATTERN *)Tnormal);

		POV_FREE(Tnormal);
	}
}

void Destroy_BBox_Tree(BBOX_TREE *Node)
{
    if(Node != NULL)
    {
        if(Node->Entries > 0)
        {
            for(short i = 0; i < Node->Entries; i++)
                Destroy_BBox_Tree(Node->Node[i]);

            POV_FREE(Node->Node);

            Node->Entries = 0;
            Node->Node = NULL;
        }

        POV_FREE(Node);
    }
}

void Destroy_Interior(INTERIOR *Interior)
{
  if ((Interior != NULL) && (--(Interior->References) == 0))
  {
    Destroy_Media(Interior->IMedia);

    POV_FREE(Interior);
  }
}

void Destroy_Fog(FOG *Fog)
{
	if (Fog != NULL)
	{
		Destroy_Turb(Fog->Turb);

		POV_FREE(Fog);
	}
}

void Destroy_Rainbow(RAINBOW *Rainbow)
{
	if (Rainbow != NULL)
	{
		Destroy_Pigment(Rainbow->Pigment);

		POV_FREE(Rainbow);
	}
}