fincsys.c

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

#include <fincsys.h>
#include <finclang.h>
#include <fincapp.h>
#include <fincnode.h>

#define FinC_ERROR printf
#define FinC_ERR_BAD_EXPR   "ERROR('%s'): '%s' nodeession of bad type\n"

void finc_sys_init ()
{
	/* Declarators
	 */
	finc_app_add_func_sys ( g_finc_app_global, "pkg", finc_sys_pkg);
	finc_app_add_func_sys ( g_finc_app_global, "struct", finc_sys_struct );
	finc_app_add_func_sys ( g_finc_app_global, "func", finc_sys_func );
	finc_app_add_func_sys ( g_finc_app_global, "global", finc_sys_global );
	finc_app_add_func_sys ( g_finc_app_global, "local", finc_sys_local );
	finc_app_add_func_sys ( g_finc_app_global, "nativefunc", finc_sys_native_func );

	finc_app_add_func_sys ( g_finc_app_global, "cast", finc_sys_cast );
	finc_app_add_func_sys ( g_finc_app_global, "addr_of", finc_sys_addr_of );
	finc_app_add_func_sys ( g_finc_app_global, "content_of", finc_sys_content_of );

	finc_app_add_func_sys ( g_finc_app_global, ".", finc_sys_access );

	finc_app_add_func_sys ( g_finc_app_global, "||", finc_sys_logic_or );
	finc_app_add_func_sys ( g_finc_app_global, "&&", finc_sys_logic_and );

	finc_app_add_func_sys ( g_finc_app_global, ",", finc_sys_comma );
	finc_app_add_func_sys ( g_finc_app_global, "?", finc_sys_condition );

	finc_app_add_func_sys ( g_finc_app_global, "+", finc_sys_add );
	finc_app_add_func_sys ( g_finc_app_global, "-", finc_sys_sub );
	finc_app_add_func_sys ( g_finc_app_global, "*", finc_sys_mul );
	finc_app_add_func_sys ( g_finc_app_global, "/", finc_sys_div );

	finc_app_add_func_sys ( g_finc_app_global, "++", finc_sys_inc );
	finc_app_add_func_sys ( g_finc_app_global, "--", finc_sys_dec );

	finc_app_add_func_sys ( g_finc_app_global, "import", finc_sys_import );

	finc_app_add_func_sys ( g_finc_app_global, "[]", finc_sys_array );

	finc_app_add_func_sys ( g_finc_app_global, "if", finc_sys_if );
	finc_app_add_func_sys ( g_finc_app_global, "for", finc_sys_for );
	finc_app_add_func_sys ( g_finc_app_global, "while", finc_sys_while );
	finc_app_add_func_sys ( g_finc_app_global, "return", finc_sys_return );
	finc_app_add_func_sys ( g_finc_app_global, "continue", finc_sys_continue );
	finc_app_add_func_sys ( g_finc_app_global, "break", finc_sys_break );

	finc_app_add_func_sys ( g_finc_app_global, "<", finc_sys_cmp_l );
	finc_app_add_func_sys ( g_finc_app_global, ">", finc_sys_cmp_g );
	finc_app_add_func_sys ( g_finc_app_global, "<=", finc_sys_cmp_le );
    	finc_app_add_func_sys ( g_finc_app_global, ">=", finc_sys_cmp_ge );
	finc_app_add_func_sys ( g_finc_app_global, "!=", finc_sys_cmp_ne );
	finc_app_add_func_sys ( g_finc_app_global, "==", finc_sys_cmp_e );

	finc_app_add_func_sys ( g_finc_app_global, "=", finc_sys_assign );

	finc_app_add_func_sys ( g_finc_app_global, "++", finc_sys_inc );
	finc_app_add_func_sys ( g_finc_app_global, "--", finc_sys_dec );

	finc_app_add_func_sys ( g_finc_app_global, "@", finc_sys_block );
}

void finc_sys_pkg (FinCNode* p_node)
{
}

void finc_sys_struct (FinCNode* p_node)
{
	FinCStruct* l_struct;

	FinCNode* l_name;
	FinCNode* l_node_field;
	FinCNode* l_node_type;

	FinCField* l_field;
	FinCType* l_type;

	int i, j;

	l_name = (FinCNode*) vector_at(p_node->vector_node, 0);

	l_struct = finc_struct_new(l_name->identifier);

	for (i=1; i<finc_node_get_size(p_node); i++)
	{
		l_node_type = vector_at(p_node->vector_node, i);
		l_type = finc_type_new (l_node_type->type->type,
			l_node_type->type->array_type, l_node_type->type->array_size);

		for (j=0; j<finc_node_get_size(l_node_type); j++)
		{
			l_node_field = vector_at (l_node_type->vector_node, j);
			l_field = finc_field_new(l_node_field->identifier, l_type);
			finc_struct_add_field(l_struct, l_field);

			unref(l_node_field);
			unref(l_field);
		}
		unref(l_type);
		unref(l_node_type);
	}

	finc_app_add_struct(g_finc_app_global, l_struct);

	unref(l_name);
	unref(l_struct);
}

void finc_sys_func ( FinCNode* p_node )
{
	FinCFunc * l_func;
	FinCNode* l_node;
	String* l_function_name;
	FinCType* l_param_type;
	String* l_param_name;
	FinCField* l_field;
	FinCNode* l_code;
	unsigned int l_size;
	unsigned int i;

	l_size = finc_node_get_size ( p_node );

	l_node = finc_node_get ( p_node, 0 );
	if ( finc_node_check ( l_node, FinCNodeType_Type ) )
	{
		unref ( l_node );
	}
	else
	{
		FinC_ERROR ( FinC_ERR_BAD_EXPR, "func", "return-type" );
		unref ( l_node );
		return ;
	}

	l_node = finc_node_get ( p_node, 1 );
	if ( finc_node_check ( l_node, FinCNodeType_Identifier ) )
	{
		l_function_name = addref ( String, l_node->identifier );
		unref ( l_node );
	}
	else
	{
		FinC_ERROR ( FinC_ERR_BAD_EXPR, "func", "function-name" );
		unref ( l_node );
		return ;
	}

	l_code = finc_node_get ( p_node, l_size - 1 );
	l_func = finc_app_add_func_node ( g_finc_app_global, string_get_str ( l_function_name ), l_code );
	unref ( l_function_name );
	unref ( l_code );

	for ( i = 0; i < ( ( l_size - 3 ) / 2 ); i++ )
	{
		l_node = finc_node_get ( p_node, 2 + ( i * 2 ) );
		if ( finc_node_check ( l_node, FinCNodeType_Type ) )
		{
			l_param_type = addref ( FinCType, l_node->type );
			unref ( l_node );
		}
		else
		{
			FinC_ERROR ( FinC_ERR_BAD_EXPR, "func", "param-type" );
			unref ( l_node );
			return ;
		}

		l_node = finc_node_get ( p_node, 2 + ( i * 2 ) + 1 );
		if ( finc_node_check ( l_node, FinCNodeType_Identifier ) )
		{
			l_param_name = addref ( String, l_node->identifier );
			unref ( l_node );
		}
		else
		{
			FinC_ERROR ( FinC_ERR_BAD_EXPR, "func", "param-name" );
			unref ( l_node );
			return ;
		}

		l_field = finc_field_new ( l_param_name, l_param_type );
		finc_func_add_param ( l_func, l_field );

		unref ( l_param_type );
		unref ( l_param_name );
		unref ( l_field );
	}
}

void finc_sys_global ( FinCNode* p_node )
{
	FinCNode* l_node;
	FinCNode* node_var;
	FinCType* l_type;
	String* l_name;
	FinCData* l_data;
	FinCVar* l_var;
	int l_size, i;

	l_node = (FinCNode*) vector_at ( p_node->vector_node, 0 ) ;
	l_type = l_node->type;
	
	l_size = finc_node_get_size(l_node);

	for ( i=0; i<l_size; i++)
	{
		node_var = (FinCNode*) vector_at ( l_node->vector_node, i );
		l_name = node_var->identifier;
		unref ( node_var );

		l_data = finc_data_new ( l_type, NULL );
		l_var = finc_var_new ( l_name, l_data );

		finc_app_add_var ( g_finc_app_global, l_var, TRUE );

		unref ( l_data );
		unref ( l_var );
	}
	unref(l_node);
}

void finc_sys_local ( FinCNode* p_node )
{
	FinCNode* l_node;
	FinCNode* node_var;
	FinCType* l_type;
	String* l_name;
	FinCData* l_data;
	FinCVar* l_var;
	FinCNode* l_init_node;
	int l_size, i;

	l_node = (FinCNode*) vector_at ( p_node->vector_node, 0 ) ;
	l_type = l_node->type;
	
	l_size = finc_node_get_size(l_node);

	for ( i=0; i<l_size; i++)
	{
		node_var = (FinCNode*) vector_at ( l_node->vector_node, i );
		l_name = node_var->identifier;

		l_data = finc_data_new ( l_type, NULL );
		
		if ( vector_get_size(node_var->vector_node)!=0 )//if has init node!
		{
			l_init_node = (FinCNode*) vector_at( node_var->vector_node, 0);
			finc_node_evaluate (l_init_node);
			finc_data_assign (l_data, l_init_node->data);
			unref(l_init_node);
		}
		unref ( node_var );

		l_var = finc_var_new ( l_name, l_data );

		finc_app_add_var ( g_finc_app_global, l_var, FALSE );

		unref ( l_data );
		unref ( l_var );
	}
	unref(l_node);
}

void finc_sys_native_func ( FinCNode* p_node)
{
}

void finc_sys_access ( FinCNode* p_node )
{
	FinCNode* l_main;
	FinCNode* l_sub;

	FinCData* l_data;
	FinCData* l_field;

	FinCStruct* l_struct;
	int l_index;

	l_main = (FinCNode*) vector_at (p_node->vector_node, 0);
	l_sub  = (FinCNode*) vector_at (p_node->vector_node, 1);

	finc_node_evaluate (l_main);

	if (!finc_node_check (l_sub, FinCNodeType_Identifier))
	{
		printf("Error:struct access, right must be a identifer!\n");
		unref(l_main);
		unref(l_sub);
		return;
	}

	l_data = addref(FinCData, l_main->data);
	l_struct = finc_app_get_struct (g_finc_app_global, l_data->type->name);
	l_index = finc_struct_get_field_index (l_struct, l_sub->identifier);
	l_field = finc_data_get_field(l_data, l_index);

	p_node->data = addref(FinCData, l_field);

	unref(l_main);
	unref(l_sub);
	unref(l_data);
	unref(l_field);
	unref(l_struct);
}

void finc_sys_array ( FinCNode* p_node )
{
	FinCNode * l_node;

	FinCData* l_data;
	FinCData* l_index;

	l_node = (FinCNode*) vector_at ( p_node->vector_node, 0 );
	finc_node_evaluate ( l_node );
	l_data = addref ( FinCData, l_node->data );
	unref ( l_node );

	l_node = FinC_NODE ( vector_at ( p_node->vector_node, 1 ) );
	finc_node_evaluate ( l_node );
	l_index = addref ( FinCData, l_node->data );
	unref ( l_node );

	unref ( p_node->data );
	p_node->data = finc_data_get_index ( l_data, access ( finc_data_get_raw_data ( l_index ), 0, int ) );

	unref ( l_data );
	unref ( l_index );
}

void finc_sys_assign ( FinCNode* p_node )
{
	FinCNode * l_node;
	FinCData* l_src;
	FinCData* l_dst;

	l_node = FinC_NODE ( vector_at ( p_node->vector_node, 0 ) );
	finc_node_evaluate ( l_node );
	l_dst = addref ( FinCData, l_node->data );
	unref ( l_node );

	l_node = FinC_NODE ( vector_at ( p_node->vector_node, 1 ) );
	finc_node_evaluate ( l_node );
	l_src = addref ( FinCData, l_node->data );
	unref ( l_node );

	finc_data_assign ( l_dst, l_src );

	unref ( l_dst );
	unref ( l_src );
}

void finc_sys_cast ( FinCNode* p_node )
{
	FinCNode* l_type_node;
	FinCNode* l_data_node;
	FinCData* l_data;

	l_type_node = (FinCNode*) vector_at ( p_node->vector_node, 0 );
	l_data_node = (FinCNode*) vector_at ( p_node->vector_node, 1 );
	finc_node_evaluate ( l_data_node );

	l_data = finc_data_new ( l_type_node->type, l_data_node->data->raw );
	unref ( l_type_node );
	unref ( l_data_node );

	unref ( p_node->data );
	p_node->data = l_data;
}

void finc_sys_addr_of ( FinCNode* p_node )
{
	FinCNode * l_node;
	FinCType* l_type;
	FinCData* l_data;

	l_type = finc_type_new ( FinCType_Pointer, FinCArrayType_None, 0 );
	l_data = finc_data_new ( l_type, NULL );
	unref ( l_type );

	l_node = (FinCNode*) vector_at ( p_node->vector_node, 0 );
	finc_node_evaluate ( l_node );

	finc_data_set_pointer (l_data, l_node->data);

	unref ( l_node );

	unref ( p_node->data );
	p_node->data = l_data;
}

void finc_sys_content_of( FinCNode* p_node)
{
	FinCNode * l_node;

	l_node = (FinCNode*) vector_at (p_node->vector_node, 0);
	finc_node_evaluate (l_node);

	unref (p_node->data);
	p_node->data = addref( FinCData,  l_node->data->pointer );
	unref (l_node);
}