/* 
*
*  ProLinga-Run
*
*  Copyright (C) 2002-2009 Xobas Software.
*  All rights reserved.
*  
*  This file is part of ProLinga-Run.
*
*  ProLinga-Run is free software: you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  ProLinga-Run is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with ProLinga-Run.  If not, see <http://www.gnu.org/licenses/>.
*
*  More information is available at the following addresses:
*
*  Website     : http://www.prolinga.org
*
*  Email       : prolinga-list@prolinga.org
*
*
*/

#include "RunCommon.h"
#include "Logic.hpp"

Parameter::Parameter()
{
	paramEntry = 0;
	paramValue = NULL;
	nextPtr = NULL;
}

Parameter::~Parameter()
{
	delete paramValue;
}

Parameter *Parameter::createList()
{
	return new Parameter;
}


char *Parameter::getValue(Parameter *paramPtr, const int entry)
{
	Parameter *curPtr;

	/* Check if parameter exist in memory */
	curPtr = paramPtr;

	while (curPtr != NULL)
	{
		if (curPtr->paramEntry == entry)
		{
			return curPtr->paramValue;
		}
		curPtr = curPtr->nextPtr;
	}

	/* Return */
	return NULL;
}

void Parameter::putValue(Parameter **paramPtr, const int entry, const char *value)
{
	Parameter *curPtr, *prevPtr, *newPtr;

	/* Check if parameter exist in memlist */
	curPtr = *paramPtr;
	prevPtr = NULL;

	while (curPtr != NULL)
	{
		if (curPtr->paramEntry == entry)
		{
			if (curPtr->paramValue != NULL)
				delete paramValue;

			curPtr->paramValue = new char[strlen(value)+1];
			strcpy(curPtr->paramValue, value);
			return;
		}
		prevPtr = curPtr;
		curPtr = curPtr->nextPtr;
	}

	/* Append new record */
	newPtr = new Parameter;
	newPtr->paramEntry = entry;
	newPtr->paramValue = new char[strlen(value)+1];
	strcpy(newPtr->paramValue, value);

	/* Next ptr null */
	newPtr->nextPtr = NULL;

	if (prevPtr == NULL)
	{
		/* First Record */
		*paramPtr = newPtr;
	}
	else
	{
		prevPtr->nextPtr = newPtr;
	}
}

int Parameter::countList(Parameter *paramPtr) const
{
	Parameter *curPtr;
	int i = 0;	

	curPtr = paramPtr;
	while (curPtr != NULL)
	{
		curPtr = curPtr->nextPtr;
		i++;
	}

	return i;
}

void Parameter::deleteList(Parameter **paramPtr)
{

	Parameter *curPtr, *nextPtr;

	curPtr = *paramPtr;
	*paramPtr = NULL;
	while (curPtr != NULL)
	{
		nextPtr = curPtr->nextPtr;
		delete curPtr;
		curPtr = nextPtr;
	}	
}


void Parameter::printList(Parameter *paramPtr) const
{
	Parameter *curPtr;

	curPtr = paramPtr;
	while (curPtr != NULL)
	{
		printf("Parameter Entry %d\n", curPtr->paramEntry);
		printf("Parameter Value %s\n", curPtr->paramValue);
		curPtr = curPtr->nextPtr;
	}
}


ParameterStack::ParameterStack()
{
	paramListPtr = NULL;
	nextPtr = NULL;
}

ParameterStack::~ParameterStack()
{
	/* Nothing ? */
}

void ParameterStack::push(ParameterStack **topPtr, Parameter *paramPtr)
{
	ParameterStack *newPtr;

	newPtr = new ParameterStack;
	newPtr->paramListPtr = paramPtr;
	newPtr->nextPtr = *topPtr;
	*topPtr = newPtr;
}

void ParameterStack::pop(ParameterStack **topPtr)
{
	ParameterStack *tmpPtr;

	tmpPtr = *topPtr;
	*topPtr = (*topPtr)->nextPtr;
	delete tmpPtr;
}

void ParameterStack::deleteStack(ParameterStack **topPtr)
{
	ParameterStack *tmpPtr;

	tmpPtr = *topPtr;
	while (*topPtr != NULL)
	{
		*topPtr = (*topPtr)->nextPtr;
		delete tmpPtr;
	}
}

Parameter *ParameterStack::getValue(ParameterStack *topPtr)
{

       if (topPtr == NULL)
                return NULL;
        else
                return topPtr->paramListPtr;
}


DataReturn::DataReturn()
{
	dataEntry = 0;
	dataRefName = NULL;
	dataRefValue = NULL;
	nextPtr = NULL;
}

DataReturn::~DataReturn()
{
	delete dataRefName;
	delete dataRefValue;
}

DataReturn *DataReturn::createList()
{
	return new DataReturn;
}


char *DataReturn::getDataRefName(DataReturn *dataPtr, const int entry)
{
	DataReturn *curPtr;

	/* Check if data exist in memory */
	curPtr = dataPtr;

	while (curPtr != NULL)
	{
		if (curPtr->dataEntry == entry)
			return curPtr->dataRefName;

		curPtr = curPtr->nextPtr;
	}

	/* Return */
	return NULL;
}

char *DataReturn::getDataRefValue(DataReturn *dataPtr, const int entry)
{
	DataReturn *curPtr;

	/* Check if data exist in memory */
	curPtr = dataPtr;

	while (curPtr != NULL)
	{
		if (curPtr->dataEntry == entry)
				return curPtr->dataRefValue;

		curPtr = curPtr->nextPtr;
	}

	/* Return */
	return NULL;
}

void DataReturn::putDataRefName(DataReturn **dataPtr, const int entry, const char *value)
{
	DataReturn *curPtr, *prevPtr, *newPtr;

	/* Check if data exist in memlist */
	curPtr = *dataPtr;
	prevPtr = NULL;

	while (curPtr != NULL)
	{
		if (curPtr->dataEntry == entry)
		{
			if (curPtr->dataRefName != NULL)
				delete dataRefName;

			curPtr->dataRefName = new char[strlen(value)+1];
			strcpy(curPtr->dataRefName, value);
			return;
		}
		prevPtr = curPtr;
		curPtr = curPtr->nextPtr;
	}

	/* Append new record */
	newPtr = new DataReturn;
	newPtr->dataEntry = entry;
	newPtr->dataRefName = new char[strlen(value)+1];
	strcpy(newPtr->dataRefName, value);

	/* Next ptr null */
	newPtr->nextPtr = NULL;

	if (prevPtr == NULL)
	{
		/* First Record */
		*dataPtr = newPtr;
	}
	else
	{
		prevPtr->nextPtr = newPtr;
	}
}

void DataReturn::putDataRefValue(DataReturn **dataPtr, const int entry, const char *value)
{
	DataReturn *curPtr, *prevPtr, *newPtr;

	/* Check if data exist in memlist */
	curPtr = *dataPtr;
	prevPtr = NULL;

	while (curPtr != NULL)
	{
		if (curPtr->dataEntry == entry)
		{
			if (curPtr->dataRefValue != NULL)
				delete dataRefValue;

			curPtr->dataRefValue = new char[strlen(value)+1];
			strcpy(curPtr->dataRefValue, value);
			return;
		}
		prevPtr = curPtr;
		curPtr = curPtr->nextPtr;
	}

	/* Append new record */
	newPtr = new DataReturn;
	newPtr->dataEntry = entry;
	newPtr->dataRefValue = new char[strlen(value)+1];
	strcpy(newPtr->dataRefValue, value);

	/* Next ptr null */
	newPtr->nextPtr = NULL;

	if (prevPtr == NULL)
	{
		/* First Record */
		*dataPtr = newPtr;
	}
	else
	{
		prevPtr->nextPtr = newPtr;
	}
}

int DataReturn::countList(DataReturn *dataPtr) const
{
	DataReturn *curPtr;
	int i = 0;	

	curPtr = dataPtr;
	while (curPtr != NULL)
	{
		curPtr = curPtr->nextPtr;
		i++;
	}

	return i;
}

void DataReturn::deleteList(DataReturn **dataPtr)
{

	DataReturn *curPtr, *nextPtr;

	curPtr = *dataPtr;
	*dataPtr = NULL;
	while (curPtr != NULL)
	{
		nextPtr = curPtr->nextPtr;
		delete curPtr;
		curPtr = nextPtr;
	}	
}


void DataReturn::printList(DataReturn *dataPtr) const
{
	DataReturn *curPtr;

	curPtr = dataPtr;
	while (curPtr != NULL)
	{
		printf("DataReturn Entry %d\n", curPtr->dataEntry);
		printf("DataReturn Name %s\n", curPtr->dataRefName);
		printf("DataReturn Value %s\n", curPtr->dataRefValue);
		curPtr = curPtr->nextPtr;
	}
}


DataReturnStack::DataReturnStack()
{
	dataListPtr = NULL;
	nextPtr = NULL;
}

DataReturnStack::~DataReturnStack()
{
	/* Nothing ? */
}

void DataReturnStack::push(DataReturnStack **topPtr, DataReturn *dataPtr)
{
	DataReturnStack *newPtr;

	newPtr = new DataReturnStack;
	newPtr->dataListPtr = dataPtr;
	newPtr->nextPtr = *topPtr;
	*topPtr = newPtr;
}

void DataReturnStack::pop(DataReturnStack **topPtr)
{
	DataReturnStack *tmpPtr;

	tmpPtr = *topPtr;
	*topPtr = (*topPtr)->nextPtr;
	delete tmpPtr;
}

void DataReturnStack::deleteStack(DataReturnStack **topPtr)
{
	DataReturnStack *tmpPtr;

	tmpPtr = *topPtr;
	while (*topPtr != NULL)
	{
		*topPtr = (*topPtr)->nextPtr;
		delete tmpPtr;
	}
}

DataReturn *DataReturnStack::getValue(DataReturnStack *topPtr)
{

       if (topPtr == NULL)
                return NULL;
        else
                return topPtr->dataListPtr;
}

ForCountStack::ForCountStack()
{
	countDataRef = NULL;
        forCount = 0;
        forStep = 0;
        forEndValue = 0;
	foreachDataModel = NULL;
        nextPtr = NULL;
}

ForCountStack::~ForCountStack()
{
	if (countDataRef != NULL)
		delete countDataRef;

	if (foreachDataModel != NULL)
		delete foreachDataModel;
}

void ForCountStack::push(ForCountStack **topPtr, const char *dataref, int count, int end, int step, char *dmName)
{
        ForCountStack *newPtr;

        newPtr = new ForCountStack;
	if (dataref == NULL)
		newPtr->countDataRef = NULL;
	else
	{
		newPtr->countDataRef = new char[(strlen(dataref)+1)];
		strcpy(newPtr->countDataRef, dataref);
	}

	if (dmName == NULL)
		newPtr->foreachDataModel = NULL;
	else
	{
		newPtr->foreachDataModel = new char[(strlen(dmName)+1)];
		strcpy(newPtr->foreachDataModel, dmName);
	}

        newPtr->forCount = count;
        newPtr->forEndValue = end;
        newPtr->forStep = step;
        newPtr->nextPtr = *topPtr;
        *topPtr = newPtr;
}

void ForCountStack::pop(ForCountStack **topPtr)
{
        ForCountStack *tmpPtr;

        tmpPtr = *topPtr;
        *topPtr = (*topPtr)->nextPtr;
        delete tmpPtr;
}

char *ForCountStack::getCountDataRef(ForCountStack *topPtr)
{
        return topPtr->countDataRef;
}

int ForCountStack::getCount(ForCountStack *topPtr)
{
        return topPtr->forCount;
}

int ForCountStack::getEndValue(ForCountStack *topPtr)
{
        return topPtr->forEndValue;
}

int ForCountStack::getStep(ForCountStack *topPtr)
{
        return topPtr->forStep;
}

char *ForCountStack::getDataModel(ForCountStack *topPtr)
{
        return topPtr->foreachDataModel;
}

void ForCountStack::putCountDataRef(ForCountStack **topPtr, char *dataref)
{
	if ((*topPtr)->countDataRef != NULL)
		delete (*topPtr)->countDataRef;

	if (dataref == NULL)
		(*topPtr)->countDataRef = NULL;
	else
	{
		(*topPtr)->countDataRef = new char[(strlen(dataref)+1)];
		strcpy(countDataRef, dataref);
	}
}

void ForCountStack::putCount(ForCountStack **topPtr, int count)
{
	(*topPtr)->forCount = count;
}

void ForCountStack::putEndValue(ForCountStack **topPtr, int end)
{
	(*topPtr)->forEndValue = end;
}

void ForCountStack::putStep(ForCountStack **topPtr, int step)
{
	(*topPtr)->forStep = step;
}

void ForCountStack::putDataModel(ForCountStack **topPtr, char *dmName)
{
	if ((*topPtr)->foreachDataModel != NULL)
		delete (*topPtr)->foreachDataModel;

	if (dmName == NULL)
		(*topPtr)->foreachDataModel = NULL;
	else
	{
		(*topPtr)->foreachDataModel = new char[(strlen(dmName)+1)];
		strcpy(foreachDataModel, dmName);
	}
}

ForBreakStack::ForBreakStack()
{
        sequenceNo = 0;
        nextPtr = NULL;
}

ForBreakStack::~ForBreakStack()
{
        /* Dummy ? */
}

void ForBreakStack::push(ForBreakStack **topPtr, int sequence)
{
        ForBreakStack *newPtr;

        newPtr = new ForBreakStack;
        newPtr->sequenceNo = sequence;
        newPtr->nextPtr = *topPtr;
        *topPtr = newPtr;
}

int ForBreakStack::pop(ForBreakStack **topPtr)
{
        ForBreakStack *tmpPtr;
	int returnValue;

        tmpPtr = *topPtr;
	returnValue = tmpPtr->sequenceNo;
        *topPtr = (*topPtr)->nextPtr;
        delete tmpPtr;
	return returnValue;
}

int ForBreakStack::getSequenceNo(ForBreakStack *topPtr)
{
	return topPtr->sequenceNo;
}