fincdata.c

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

#include <fincdata.h>
#include <fincfield.h>
#include <fincstruct.h>
#include <fincapp.h>

extern FinCApp* g_finc_app_global;

FinCData* finc_data_new ( FinCType* p_type, ADT p_ref )
{
    FinCData * self;
	FinCStruct* l_struct;

    self = (FinCData*)mem_new(sizeof(FinCData));
    object_init_object ( OBJECT ( self ), finc_data_destroy );
    self->type = addref ( FinCType, p_type );
    self->pointer = NULL;

    if ( p_ref )
    {
    	self->ref = TRUE;
    	self->raw = p_ref;
		if ( p_type->type & FinCType_Struct )
		{
			l_struct = finc_app_get_struct (g_finc_app_global, p_type->name);
			self->vector_child = finc_struct_init_data(l_struct, self->raw);
			unref(l_struct);
		}
    	return self;
    }

    self->ref = FALSE;
    self->raw = NULL;
    finc_data_init_data ( self, NULL );

    return self;
}

/*
copy p_data to new data, but without its ref.
struct type:
*/
FinCData* finc_data_new_copy (FinCData* p_data)
{
	FinCData* self;

	self = finc_data_new (p_data->type, NULL);
	mem_copy(p_data->raw, self->raw, finc_type_get_size(p_data->type));

	if ( p_data->pointer )
	{
		self->pointer = addref(FinCData, p_data->pointer);
	}

	return self;
}

/*
use p_str to generate a string type data.
*/
FinCData* finc_data_new_string (unsigned char* p_str)
{
	FinCData* self;
	FinCData* l_str;
	FinCType* l_type;

	l_type = finc_type_new ( FinCType_String, FinCArrayType_None, 0);
	self = finc_data_new( l_type, NULL);
	unref(l_type);

	l_str = finc_data_new_raw_string (p_str);

	mem_copy(&l_str->raw, self->raw, sizeof(ADT));
	self->pointer = addref(FinCData, l_str);
	unref(l_str);

	return self;
}

/*
use p_str to generate a raw string data, it will copy p_str to new raw data.
*/
FinCData* finc_data_new_raw_string (unsigned char* p_str)
{
	FinCData* self;
	FinCType* l_type;
	int l_size;

	l_size = strlen(p_str)+1;

	l_type = finc_type_new (FinCType_Char, FinCArrayType_Fixed, l_size);
	self = finc_data_new( l_type, NULL);
	unref(l_type);

	mem_copy( p_str, self->raw, l_size);

	return self;
}

void finc_data_destroy ( Object* self )
{
	FinCData* l_self;
	
	l_self = (FinCData*)self;
	
	unref(l_self->vector_child);

	if ( (l_self->type->type & FinCType_String)||(l_self->type->type & FinCType_Pointer) )
	{
		unref(l_self->pointer);
		if (!l_self->ref) mem_destroy(l_self->raw);/*release the pointer data!*/
	}
	else if ( !l_self->ref )
	{
		mem_destroy(l_self->raw);
	}

	l_self->raw = NULL;
	unref(l_self->type);

	mem_destroy ( l_self );
}

void finc_data_init_data ( ADT self, ADT data )
{
    FinCData* l_data;
    int i;
    unsigned int l_array;
    FinCStruct* l_struct;

    l_data = ( FinCData* ) self;

    if ( l_data->type->array_type == FinCArrayType_None )
        l_array = 1;
    else
        l_array = l_data->type->array_size;

    /*alloc new data block*/
    l_data->raw = (ADT) mem_new ( finc_type_get_size(l_data->type)*l_array );

    if (( l_data->type->type & FinCType_String )||( l_data->type->type & FinCType_Pointer ))
    {
		/*mem_destroy(l_data->raw);*/
        for ( i = 0; i < l_array; i++ )
    	    access ( l_data->raw, i * sizeof( ADT ), ADT ) = NULL;
    }
    else if ( l_data->type->type & FinCType_Int )
    {
        for ( i = 0; i < l_array; i++ )
    	    access ( l_data->raw, i*sizeof(int), int ) = 0;
    }
    else if ( l_data->type->type & FinCType_Float )
    {
        for ( i = 0; i < l_array; i++ )
    	    access ( l_data->raw, i*sizeof(float), float ) = 0.0;
    }
    else if ( l_data->type->type & FinCType_Bool )
    {
        for ( i = 0; i < l_array; i++ )
	    access ( l_data->raw, i*sizeof(Bool), Bool ) = FALSE;
    }
    else if ( l_data->type->type & FinCType_Struct )
    {
		l_struct = finc_app_get_struct (g_finc_app_global, l_data->type->name);
		l_data->vector_child = finc_struct_init_data(l_struct, l_data->raw);
		unref(l_struct);
    }
}

String* finc_data_get_string ( FinCData* self )
{
	String * l_text;

	l_text = string_new ();
	string_set_str ( l_text, access ( self->raw, 0, char* ) );

	return l_text;
}

void finc_data_set_string ( FinCData* self, String* p_value )
{
	int l_size;
	FinCData* l_string;
	FinCType* l_type;

	l_size = string_get_size ( p_value )+1;
	l_type = finc_type_new(FinCType_Char, FinCArrayType_Fixed, l_size);
	l_string = finc_data_new(l_type, NULL);

	mem_copy ( string_get_str(p_value), l_string->raw, l_size);

	if(self->pointer)unref(self->pointer);
	self->pointer = addref(FinCData, l_string);

	self->raw = l_string->raw;
	unref(l_string);
}

void finc_data_assign ( FinCData* self, FinCData* p_src )
{
	FinCData* l_data;
	char l_str[ 1000 ];

	if ( !p_src )
	{
		printf ( "Runtime error: Source Data not available\n" );
		return ;
	}

	if ( !self )
	{
		printf ( "Runtime error: Dest Data not available\n" );
		return ;
	}

	if ( self->type->type & FinCType_String )
	{
		if ( p_src->type->type & FinCType_String )
		{
			l_data = finc_data_new_copy(p_src->pointer);
			unref(self->pointer);
			self->pointer = addref(FinCData, l_data);
			unref(l_data);
			mem_copy(&self->pointer->raw, self->raw, sizeof(ADT));
		}
		if ( p_src->type->type & FinCType_Int )
		{
			sprintf ( l_str, "%d", access ( p_src->raw, 0, unsigned int ) );
			l_data = finc_data_new_string (l_str);
			unref(self->pointer);
			self->pointer = addref(FinCData, l_data);
			unref(l_data);
			mem_copy(&self->pointer->raw, self->raw, sizeof(ADT));
		}
		if ( p_src->type->type & FinCType_Float )
		{
			sprintf ( l_str, "%f", access ( p_src->raw, 0, float ) );
			l_data = finc_data_new_string (l_str);
			unref(self->pointer);
			self->pointer = addref(FinCData, l_data);
			unref(l_data);
			mem_copy(&self->pointer->raw, self->raw, sizeof(ADT));
		}
		if ( p_src->type->type & FinCType_Double )
		{
			sprintf ( l_str, "%f", access ( p_src->raw, 0, double ) );
			l_data = finc_data_new_string (l_str);
			unref(self->pointer);
			self->pointer = addref(FinCData, l_data);
			unref(l_data);
			mem_copy(&self->pointer->raw, self->raw, sizeof(ADT));
		}
	}

	if ( self->type->type & FinCType_Int )
	{
		access ( self->raw, 0, int ) = access ( p_src->raw, 0, int );
	}

	if ( self->type->type & FinCType_Short )
	{
		access ( self->raw, 0, short ) = access ( p_src->raw, 0, short );
	}

	if ( self->type->type & FinCType_Float )
	{
		access ( self->raw, 0, float ) = access ( p_src->raw, 0, float );
	}

	if ( self->type->type & FinCType_Pointer )
	{
		finc_data_set_pointer( self, p_src->pointer);
	}

	if ( self->type->type & FinCType_Struct )
	{
		printf("not implement yet!\n");
	}
}

FinCData* finc_data_convert ( FinCData* self, FinCType* p_type )
{
	return NULL;
}

/*
used by array data type
*/
FinCData* finc_data_get_index ( FinCData* self, int p_index )
{
	FinCData * l_data;
	FinCType* l_type;

	l_type = finc_type_new ( self->type->type, FinCArrayType_None, 0 );
	l_data = finc_data_new ( l_type, &access ( self->raw, ( p_index * sizeof( ADT ) ), ADT ) );
	unref(l_type);

	return l_data;
}

void finc_data_set_pointer ( FinCData* self, FinCData* p_raw )
{
	if ( !self )
	{
		printf("Runtime Error: pointer source data unavailable.\n");
		return;
	}

	if(self->pointer)unref(self->pointer);
	self->pointer = addref(FinCData, p_raw);

	mem_copy(&p_raw->raw, self->raw, sizeof(ADT));
}

FinCData* finc_data_get_pointer ( FinCData* self)
{
	return addref(FinCData, self->pointer);
}

ADT finc_data_get_raw_data ( FinCData* self)
{
	return self->raw;
}

FinCData* finc_data_get_field (FinCData* self, int p_index)
{
	if (!self) return NULL;

	if (!( self->type->type & FinCType_Struct )) return NULL;

	return vector_at(self->vector_child, p_index);
}