rpnifs/rpn_if_default.c

#include "rpn_if_default.h"

rpn_if_param_t* rpn_if_default_params(short pos_flag, short res_flag,
	const size_t *lim, const rpn_value_t *res_const,
	unsigned char rpn_stack_sz)
{
	rpn_if_param_t *res;
	rpn_if_default_data_t *data;
	size_t lim_sz, const_val_sz, param_sz, rpn_sz, mem_sz, ndim, value_sz, argc, i;

	// Calculating full params + default_data + size_lim + const_val size
	short lim_off = 0;
	switch(pos_flag)
	{
		case RPN_IF_POSITION_LINEAR:
			ndim = lim_sz = 1;
			break;
		case RPN_IF_POSITION_XY:
			ndim = lim_sz = 2;
			break;
		case RPN_IF_POSITION_XDIM:
			ndim = lim_sz = *lim;
			lim_sz++;
			lim_off = 1;
			break;
		default:
			fprintf(stderr,
				"Invalid position flag for if params : %d\n",
				pos_flag);
			return NULL;
	}
	mem_sz = 1;
	for(i=0;i<ndim;i++)
	{
		mem_sz *= lim[i+lim_off];
	}
	argc = rpn_sz = ndim;
	lim_sz *= sizeof(size_t);

	const_val_sz = 0;
	switch(res_flag)
	{
		case RPN_IF_RES_BOOL:
			rpn_sz += 1;
			argc += 1;
			value_sz = sizeof(rpn_value_t);
			break;
		case RPN_IF_RES_COUNT:
			argc += 1;
			value_sz = sizeof(rpn_value_t);
			break;
		case RPN_IF_RES_XFUN:
			rpn_sz += 1;
			argc += 1;
			value_sz = sizeof(rpn_value_t);
			break;
		case RPN_IF_RES_RGB:
			rpn_sz += 3;
			argc += 3;
			value_sz = sizeof(rpn_value_t) * 3;
			break;
		case RPN_IF_RES_RGBA:
			rpn_sz += 4;
			argc += 4;
			value_sz = sizeof(rpn_value_t) * 4;
			break;
		case RPN_IF_RES_CONST:
			const_val_sz = 1;
			argc += 1;
			value_sz = sizeof(rpn_value_t);
			break;
		/*
		case RPN_IF_RES_CONST_RGB:
			const_val_sz = 3;
			argc += 3;
			break;
		*/
		case RPN_IF_RES_CONST_RGBA:
			const_val_sz = 4;
			argc += 4;
			value_sz = sizeof(rpn_value_t) * 4;
			break;
		default:
			fprintf(stderr,
				"Invalid result flag for if params : %d\n",
				pos_flag);
			return NULL;
	}
	if(const_val_sz && !res_const)
	{
		fprintf(stderr,
			"Missing values when creating if params");
		return NULL;
	}
	else if(!const_val_sz && res_const)
	{
		//Warning
	}
	const_val_sz *= sizeof(rpn_value_t);

	param_sz = lim_sz + const_val_sz + \
		sizeof(rpn_if_param_t) + sizeof(rpn_if_default_data_t);

	//Allocating result and setting fields values
	res = malloc(param_sz);
	if(!res)
	{
		perror("Unable to alloc iterated function params");
		return NULL;
	}
	res->data = data = (rpn_if_default_data_t*)(&(res[1]));

	data->pos_flag = pos_flag;
	data->res_flag = res_flag;
	data->ndim = ndim;
	data->size_lim = (size_t*)&(data[1]);
	data->const_val = ((void*)data->size_lim) + lim_sz;

	memcpy(data->size_lim, lim, lim_sz);

	if(const_val_sz)
	{
		memcpy(data->const_val, res_const, const_val_sz);
	}
	else
	{
		data->const_val = NULL;
	}

	res->getarg_f = rpn_if_getarg_default;
	res->setres_f = rpn_if_setres_default;

	res->rpn_argc = argc;
	res->rpn_stack_sz = rpn_stack_sz;
	res->value_sz = value_sz;
	res->mem_sz = mem_sz;
	res->rpn_sz = rpn_sz;

	return res;
}

int rpn_if_sizes_from_flag(short pos_flag, short res_flag, short sizes[2])
{
	short *lim_sz = &sizes[0];
	short *const_sz = &sizes[1];

	*lim_sz = *const_sz = -1;

	switch(pos_flag)
	{
		case RPN_IF_POSITION_LINEAR:
			*lim_sz = 1;
			break;
		case RPN_IF_POSITION_XY:
			*lim_sz = 2;
			break;
		case RPN_IF_POSITION_XDIM:
			*lim_sz = 1;
			break;
		default:
			return -1;
	}
	switch(res_flag)
	{
		case RPN_IF_RES_CONST:
			*const_sz = 1;
			break;
		/*
		case RPN_IF_RES_CONST_RGB:
			*const_sz = 3;
			break;
		*/
		case RPN_IF_RES_CONST_RGBA:
			*const_sz = 4;
			break;
		case RPN_IF_RES_BOOL:
		case RPN_IF_RES_COUNT:
		case RPN_IF_RES_XFUN:
		case RPN_IF_RES_RGB:
		case RPN_IF_RES_RGBA:
			*const_sz = 0;
			break;
		default:
			return -1;
	}
	return 0;
}

int rpn_if_getarg_default(rpn_if_t *rif, size_t pos)
{
	size_t cur_arg, i, rgb_imax;
	rpn_if_default_data_t *data;
	rpn_value_t *values;
	rpn_value_t *args = rif->rpn_args;

	data = (rpn_if_default_data_t*)rif->params->data;

	switch(data->pos_flag)
	{
		case RPN_IF_POSITION_LINEAR:
			rpn_if_argf_linear(rif, pos, args);
			cur_arg = 1;
			break;
		case RPN_IF_POSITION_XY:
			rpn_if_argf_xy(rif, pos, args);
			cur_arg = 2;
			break;
		case RPN_IF_POSITION_XDIM:
			rpn_if_argf_xdim(rif, pos, args);
			cur_arg = *(data->size_lim);
			break;
		default:
			return -1;
	}
	if(cur_arg > rif->params->rpn_argc)
	{
		/* Too many arguments for given rif !! */
		return -1;
	}
	rgb_imax = 4; /* rgba */
	values = rpn_if_getitem(rif, pos);
	switch(data->res_flag)
	{
		case RPN_IF_RES_BOOL:
			args[cur_arg] = values[0]?1:0;
			break;
		case RPN_IF_RES_CONST:
		case RPN_IF_RES_COUNT:
			args[cur_arg] = *values;
			break;
		case RPN_IF_RES_RGB:
			rgb_imax = 3;
		case RPN_IF_RES_CONST_RGBA:
		case RPN_IF_RES_RGBA:
			for(i=0; i<rgb_imax; i++)
			{
				args[cur_arg+i] = values[i];
			}
			break;
		case RPN_IF_RES_XFUN:
			for(i=0; i < rif->params->rpn_sz - cur_arg; i++)
			{
				args[cur_arg+i] = values[i];
			}
			break;
		default:
			/* LOG ERROR */
			return -1;
	}
	return -1;
}

int rpn_if_setres_default(rpn_if_t *rif, size_t *pos)
{
	rpn_if_default_data_t *data;
	size_t cur_arg, i, rgb_imax;
	rpn_value_t *values;
	rpn_value_t *res = rif->rpn_res;

	data = (rpn_if_default_data_t*)rif->params->data;

	switch(data->pos_flag)
	{
		case RPN_IF_POSITION_LINEAR:
			rpn_if_resf_linear(rif, pos, res);
			cur_arg = 1;
			break;
		case RPN_IF_POSITION_XY:
			rpn_if_resf_xy(rif, pos, res);
			cur_arg = 2;
			break;
		case RPN_IF_POSITION_XDIM:
			rpn_if_resf_xdim(rif, pos, res);
			cur_arg = *(data->size_lim);
			break;
		default:
			return -1;
	}
	if(cur_arg > rif->params->rpn_argc)
	{
		/** LOG ERROR ! should never append... */
		return -1;
	}
	rgb_imax = 3; /* rgb */
	values = rpn_if_getitem(rif, *pos);
	/**@todo if(res) set the values in res too ! */
	switch(data->res_flag)
	{
		case RPN_IF_RES_BOOL:
			*values = 1;
			break;

		case RPN_IF_RES_CONST:
			*values = *(data->const_val);
			break;

		case RPN_IF_RES_COUNT:
			(*values)++;
			break;

		case RPN_IF_RES_CONST_RGBA:
			rgb_imax = 4;
		//case RPN_IF_RES_CONST_RGB:
			for(i=0;i<rgb_imax;i++)
			{
				values[i] = data->const_val[i];
			}
			break;

		case RPN_IF_RES_RGBA:
			rgb_imax = 4;
		case RPN_IF_RES_RGB:
			for(i=0;i<rgb_imax;i++)
			{
				values[i] = rif->rpn_res[cur_arg+i];
			}
			break;

		case RPN_IF_RES_XFUN:
			for(i=0; i<rif->params->rpn_sz - cur_arg; i++)
			{
				values[i] = rif->rpn_res[cur_arg+i];
			}
			break;

		default:
			/* LOG ERROR */
			return -1;
	}
	return 0;
}

int rpn_if_argf_linear(rpn_if_t *rif, size_t pos, rpn_value_t *args)
{
	rpn_if_default_data_t *data;
	data = (rpn_if_default_data_t*)rif->params->data;
	if(data->size_lim && pos >= *data->size_lim)
	{
		if(data->pos_flag & RPN_IF_POSITION_OF_ERR)
		{
			return -1;
		}
		pos %= *(data->size_lim);
	}
	args[0] = pos;
	return 0;
}

int rpn_if_resf_linear(rpn_if_t *rif, size_t *pos, rpn_value_t *_data)
{
	rpn_if_default_data_t *data;
	size_t res;
	data = (rpn_if_default_data_t*)rif->params->data;
	res = rif->rpn_res[0];
	if(data->size_lim && res >= *data->size_lim)
	{
		if(data->pos_flag & RPN_IF_POSITION_OF_ERR)
		{
			return -1;
		}
		res %= *(data->size_lim);
	}
	*pos = res;
	return 0;
}

int rpn_if_argf_xy(rpn_if_t *rif, size_t pos, rpn_value_t *args)
{
	rpn_if_default_data_t *data;

	data = (rpn_if_default_data_t*)rif->params->data;
	if(!data->size_lim)
	{
		return -1;
	}
	args[0] = pos % data->size_lim[0];
	args[1] = pos / data->size_lim[0];
	if(args[1] > data->size_lim[1])
	{
		if(data->pos_flag & RPN_IF_POSITION_OF_ERR)
		{
			return -1;
		}
		args[1] %= data->size_lim[1];
	}
	return 0;
}

int rpn_if_resf_xy(rpn_if_t *rif, size_t *pos, rpn_value_t *_data)
{
	rpn_if_default_data_t *data;
	size_t xy[2];

	data = (rpn_if_default_data_t*)rif->params->data;
	
	xy[0] = rif->rpn_res[0];
	xy[1] = rif->rpn_res[1];

	if(!data->size_lim)
	{
		return -1;
	}

	if(xy[0] >= data->size_lim[0] || xy[1] >= data->size_lim[1])
	{
		if(data->pos_flag & RPN_IF_POSITION_OF_ERR)
		{
			return -1;
		}
		xy[0] %= data->size_lim[0];
		xy[1] %= data->size_lim[1];
	}
	*pos = xy[0]+(xy[1]*data->size_lim[0]);
	return 0;
}

int rpn_if_argf_xdim(rpn_if_t *rif, size_t pos, rpn_value_t *args)
{
	rpn_if_default_data_t *data;
	size_t i, curdim_sz, curpos;

	data = (rpn_if_default_data_t*)rif->params->data;

	if(!data->size_lim)
	{
		return -1;
	}
	if(*(data->size_lim) < 1)
	{
		return -1;
	}
	/**@todo check if *(data->size_lim) overflow rif->params->rpn_argc */

	curdim_sz = 1;
	curpos = pos;
	for(i=0; i<*(data->size_lim)-1; i++)
	{
		curdim_sz = data->size_lim[i+1];
		args[i] = curpos % curdim_sz;
		curpos /= curdim_sz;
	}
	args[i] = curpos;
	if(args[i] >= curdim_sz)
	{
		if(data->pos_flag && RPN_IF_POSITION_OF_ERR)
		{
			return -1;
		}
		args[i] %= curdim_sz;
	}
	return 0;
}

int rpn_if_resf_xdim(rpn_if_t *rif, size_t *pos, rpn_value_t *_data)
{
	rpn_if_default_data_t *data;
	size_t i, res, cur, curlim, dim_sz;

	data = (rpn_if_default_data_t*)rif->params->data;
	res = 0;
	
	if(!data->size_lim)
	{
		return -1;
	}
	if(*(data->size_lim) < 1)
	{
		return -1;
	}
	/**@todo check if *(data->size_lim) overflow rif->params->rpn_argc */

	dim_sz = 1;
	for(i=0;  i < *(data->size_lim); i++)
	{
		cur = rif->rpn_res[i];
		curlim = data->size_lim[i+1];
		if(cur >= curlim)
		{
			if(data->pos_flag & RPN_IF_POSITION_OF_ERR)
			{
				return -1;
			}
			cur %= curlim;
		}
		res += cur * dim_sz;
		dim_sz *= curlim;
	}
	*pos = res;
	return 0;
}