fincfunc.c

FinC is Fava in C! A C-like syntax language. It s designed to apply to embededd system.

#include <fincfunc.h>
#include <fincapp.h>
#include <finclang.h>

void* (* finc_func_direct_void) ();
void* (* finc_func_direct) (int x, ...);

float (* finc_func_direct_void_f32) ();
float (* finc_func_direct_f32) (int x, ...);

FinCData* g_finc_func_return = NULL;
Bool g_finc_func_halt = FALSE;

FinCFunc* finc_func_new ()
{
	FinCFunc *self;

	self = (FinCFunc*)mem_new(sizeof(FinCFunc));
	object_init_object (OBJECT (self), finc_func_destroy);

	self->type = FinCFuncType_None;
	self->node = NULL;
	self->ret_type = NULL;
	self->name = string_new ();
	self->vector_params = vector_new ();
	self->opt_param = FALSE;

	return self;
}

void finc_func_destroy (Object* self)
{
	unref ( ((FinCFunc*)self)->node);
	unref ( ((FinCFunc*)self)->name);
	unref ( ((FinCFunc*)self)->ret_type);
	unref ( ((FinCFunc*)self)->vector_params);

	mem_destroy (self);
}

void finc_func_set_sys (FinCFunc* self, String* p_name, FinCFuncSys p_sys)
{
	self->type = FinCFuncType_Sys;
	self->sys = p_sys;

	unref (self->name);
	self->name = addref (String, p_name);
}

void finc_func_set_native (FinCFunc* self, String* p_name, void* p_native)
{
	self->type = FinCFuncType_Native;
	self->native = p_native;

	unref (self->name);
	self->name = addref (String, p_name);
}

void finc_func_set_node (FinCFunc* self, String* p_name, FinCNode* p_node)
{
	self->type = FinCFuncType_Node;

	unref (self->name);
	self->name = addref (String, p_name);

	unref (self->node);
	self->node = addref (FinCNode, p_node);
}

void* finc_func_get_ptr (FinCFunc* self)
{
	return NULL;
}

void finc_func_add_param (FinCFunc* self, FinCField* p_param)
{
	vector_append (self->vector_params, (Object*) p_param);
}

void finc_func_call_init (FinCFunc* self)
{
}

void finc_func_push (FinCFunc* self, FinCData* p_param)
{
}

FinCData* finc_func_call (FinCFunc* self, FinCNode* p_node)
{
	HashTable* l_context;
	FinCVar* l_var;
	FinCData* l_data;
	FinCData* l_return;
	FinCNode* l_node;
	FinCField* l_field;
	String* l_name;
	int l_size;
	int i, j;
	ADT l_ret;
	float l_retf = 0;
	unsigned int params[10];

	switch (self->type)
	{
	case FinCFuncType_Sys://language system function
		(*(self->sys)) (p_node);
		return p_node->data;
		break;
		
	case FinCFuncType_Native://native function
		j = 0;
		if (!self->opt_param)
			l_size = vector_get_size (self->vector_params);/*if not ...*/
		else
			l_size = vector_get_size (p_node->vector_node);/*if use '...', use real script params.*/

		for (i=0; i<l_size; i++)
		{
			l_field = (FinCField*) vector_at (self->vector_params, i);
			l_node =  (FinCNode*) vector_at (p_node->vector_node, i);
			finc_node_evaluate (l_node);

			if (l_node->data)
			{
				if (l_node->data->type->type & FinCType_String)
				{
					params[j] = (unsigned int) *(long*)finc_data_get_raw_data (l_node->data);
				}
				else if ( l_node->data->type->type & FinCType_Pointer)
				{
					params[j] = (unsigned int) *(long*)finc_data_get_raw_data (l_node->data);
				}
				else
				{
					if (l_field)
					{
						if ( l_node->data->type->type & FinCType_Float &&
								l_field->type->type & FinCType_Double)
						{
							*((double*) &params[j]) = access (finc_data_get_raw_data (l_node->data), 0, float);
							j++;
						}
					}
					else
						params[j] = access (finc_data_get_raw_data (l_node->data), 0, unsigned int);
				}
			}
			else
				params[j] = 0;

			j++;

			unref (l_field);
			unref (l_node);
		}

		finc_func_direct = self->native;
		finc_func_direct_void = self->native;
		finc_func_direct_f32 = self->native;
		finc_func_direct_void_f32 = self->native;

		l_ret = 0;

		if (self->ret_type->type & FinCType_Float)
		{
			switch (j)
			{
			case 0:
				l_retf = (*finc_func_direct_void_f32) ();
				break;
			case 1:
				l_retf = finc_func_direct_f32 (params[0]);
				break;
			case 2:
				l_retf = (*finc_func_direct_f32) (params[0], params[1]);
				break;
			case 3:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2]);
				break;
			case 4:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3]);
				break;
			case 5:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3], params[4]);
				break;
			case 6:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3], params[4],
					params[5]);
				break;
			case 7:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3], params[4],
					params[5], params[6]);
				break;
			case 8:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3], params[4],
				    params[5], params[6], params[7]);
				break;
			case 9:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3], params[4],
				    params[5], params[6], params[7], params[8]);
				break;
			case 10:
				l_retf = (*finc_func_direct_f32) (params[0], params[1], params[2], params[3], params[4],
				    params[5], params[6], params[7], params[8], params[9]);
				break;
			}
		}
		else
		{
			switch (j)
			{
			case 0:
				l_ret = (*finc_func_direct_void) ();
				break;
			case 1:
				l_ret = (*finc_func_direct) (params[0]);
				break;
			case 2:
				l_ret = (*finc_func_direct) (params[0], params[1]);
				break;
			case 3:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2]);
				break;
			case 4:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3]);
				break;
			case 5:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3], params[4]);
				break;
			case 6:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3], params[4],
					params[5]);
				break;
			case 7:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3], params[4],
					params[5], params[6]);
				break;
			case 8:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3], params[4],
				    params[5], params[6], params[7]);
				break;
			case 9:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3], params[4],
				    params[5], params[6], params[7], params[8]);
				break;
			case 10:
				l_ret = (*finc_func_direct) (params[0], params[1], params[2], params[3], params[4],
				    params[5], params[6], params[7], params[8], params[9]);
				break;
			}
		}

		//bug after call function, should release data;

		l_data = finc_data_new (self->ret_type, NULL);

		switch (self->ret_type->type)
		{
		case FinCType_String:
			finc_data_set_string (l_data, (String*) l_ret);
			unref (l_ret);
			break;
		case FinCType_Float:
			access (finc_data_get_raw_data (l_data), 0, float) = l_retf;
			break;
		case FinCType_Double:
			access (finc_data_get_raw_data (l_data), 0, double) = l_retf;
			break;
		case FinCType_Int:
		case FinCType_Pointer:
			access (finc_data_get_raw_data (l_data), 0, void*) = l_ret;
			break;
		case FinCType_Void:
		case FinCType_Char:
		case FinCType_Short:
		case FinCType_Bool:
		case FinCType_Struct:
		case FinCType_Func:
		case FinCType_Unsigned:
		case FinCType_Static:
		case FinCType_Native:
		  break;
		}

		return l_data;
		break;

	case FinCFuncType_Node://FinC script function
		if (p_node)
		{
			l_size = vector_get_size (self->vector_params);
			for (i=0; i<l_size; i++)
			{
				l_node =  (FinCNode*) vector_at (p_node->vector_node, i);
				finc_node_evaluate (l_node);
				unref (l_node);
			}
		}
		l_context = finc_app_func_enter (g_finc_app_global);

		if (p_node)
		{
			l_size = vector_get_size (self->vector_params);

			for (i=0; i<l_size; i++)
			{
				l_field = (FinCField*) vector_at (self->vector_params, i);//bug for ...(opt_params)
				l_node =  (FinCNode*) vector_at (p_node->vector_node, i);

				l_name = l_field->name;
				l_var = finc_var_new_copy (l_name, l_node->data);

				finc_app_add_var (g_finc_app_global, l_var, FALSE);

				unref (l_field);
				unref (l_node);
				unref (l_var);
			}
		}

		g_finc_func_halt = FALSE;
		finc_node_evaluate (self->node);//execute function body!
		g_finc_func_halt = FALSE;

		finc_app_func_leave (g_finc_app_global, l_context);

		l_return = g_finc_func_return;
		g_finc_func_return = NULL;
		return l_return;

		break;
	default:
		break;
	}

	return NULL;
}