//================================================================================
//================================================================================
//================================================================================
//==============================the object========================================
//================================================================================
//================================================================================
//================================================================================
//=========================================================================

//-----------------------------------------------------------------------------------------------------------------


char noidea_nibble2hex(int noidea_int)
{
	char noidea_tmp = 0;
	if ((noidea_int>=0)&&(noidea_int<=15))
	{
		if (noidea_int<=9)
		{
			noidea_tmp = (char)(48 + noidea_int);
		}
		else
		{
			noidea_tmp = (char)(65 + noidea_int - 10);
		}
	}
	return noidea_tmp;
}

int noidea_hex2nibble(char noidea_char)
{
	int noidea_tmp = 0;
	if ((noidea_char >= 48)&&(noidea_char <= 57))
	{
		noidea_tmp = (char)(noidea_char - 48);
	}
	if ((noidea_char >= 65)&&(noidea_char <= 70))
	{
		noidea_tmp = (char)(noidea_char - 65);	
	}
	return noidea_tmp;
}

int noidea_getexp(float noidea_float, int noidea_gage)
{
	int noidea_tmp = 0;
	noidea_float = noidea_float - (int)noidea_float;
	while (noidea_float != 0)
	{
		noidea_float = noidea_float * noidea_gage;
		noidea_float = noidea_float - (int)noidea_float;
		noidea_tmp = noidea_tmp + 1;
	}
	return noidea_tmp;
}

int noidea_intpow(int noidea_int, int noidea_pow)
{
	int noidea_tmp = 1;
	while (noidea_pow != 0)
	{
		noidea_tmp = noidea_tmp * noidea_int;
		noidea_pow = noidea_pow - 1;
	}
	return noidea_tmp;
}

int noidea_getsize(int noidea_int,int noidea_gage)
{
	int noidea_tmp = 0;
	while (noidea_int != 0)
	{
		noidea_int = noidea_int / noidea_gage;
		noidea_tmp = noidea_tmp + 1;
	}
	return noidea_tmp;
}

NOIDEA_node * noidea_push(noidea_env * noidea_self , char * noidea_str)
{
	//get the size of the str
	int noidea_size = 0;
	while (*(noidea_str + noidea_size) != (char)35)
	{
		noidea_size += sizeof(char);
	}
	//readjust size to make sure its void* size
	noidea_size += (sizeof(void*) - (noidea_size % sizeof(void*)));
	//alloc memory node for the str
	NOIDEA_node * noidea_nud = noidea_append(noidea_self, sizeof(char) * noidea_size);
	char * noidea_ptr = noidea_nud->pack;
	//copy the str to the node
	int noidea_tmp = 0;
	while (noidea_tmp <= noidea_size)
	{
		char noidea_char = *(noidea_str + noidea_tmp); 
		*(noidea_ptr + noidea_tmp) = noidea_char;
		noidea_tmp += sizeof(char);
	}
	return noidea_nud;
}

char * noidea_pop(NOIDEA_node * noidea_nud)
{
	//build temporary str
	char noidea_tmp[128];
	char * noidea_ptr = noidea_tmp;
	char * noidea_str = noidea_nud->pack;
	//build other temporary var
	int noidea_index = 0;
	//extract
	while (*(noidea_str + noidea_index) != 35)
	{
		*(noidea_ptr + noidea_index) = *(noidea_str + noidea_index);
		noidea_index += sizeof(char);
	}
	return noidea_ptr;
}

char * noidea_float2str(float noidea_float, int noidea_format)
{
	if ((noidea_format != 2)&&(noidea_format != 10)&&(noidea_format != 16))
	{
		return 0;
	}
	//temporary array
	char noidea_txt[1024 * sizeof(char)];
	char * noidea_str = noidea_txt;
	//check the presence of the sign
	int noidea_sign = 0;
	if (noidea_float < 0)
	{
		noidea_sign = 1;
		noidea_float = 0 - noidea_float;
	}
	//check the presence of a floating point
	int noidea_point = 0;
	if (noidea_float - (int)noidea_float != 0)
	{
		noidea_point = 1;
	}
	//get the size of the str
	int noidea_exp = noidea_getexp(noidea_float,noidea_format);
	int noidea_int = (int)(noidea_float * noidea_intpow(noidea_format, noidea_exp));
	int noidea_size = noidea_getsize((int)noidea_float,noidea_format);
	//character termination = 35 "#" 
	*(noidea_str + (sizeof(char) * (noidea_sign+noidea_size+noidea_point+noidea_exp+1))) = (char)35;
	//all digit below 1
	while (noidea_exp != 0)
	{
		*(noidea_str + (sizeof(char) * (noidea_sign+noidea_size+noidea_point+noidea_exp))) = noidea_nibble2hex(noidea_int % noidea_format);
		noidea_int = noidea_int / noidea_format;
		noidea_exp = noidea_exp - 1;
	}
	//point
	if (noidea_point != 0)
	{
		*(noidea_str + (sizeof(char) * (noidea_sign+noidea_size+noidea_point))) = (char)46;
	}
	//all hexadecimal that remain
	while (noidea_size != 0)
	{
		*(noidea_str + (sizeof(char) * (noidea_sign+noidea_size))) = noidea_nibble2hex(noidea_int % noidea_format);
		noidea_int = noidea_int / noidea_format;
		noidea_size = noidea_size - 1;
	}
	//sign
	if (noidea_sign != 0)
	{
		*(noidea_str + (sizeof(char) * (noidea_sign))) = (char)45;
	}
	//identification character
	if (noidea_format == 2)
	{
		*(noidea_str) = (char)98;
	}
	if (noidea_format == 10)
	{
		*(noidea_str) = (char)100;
	}
	if (noidea_format == 16)
	{
		*(noidea_str) = (char)104;
	}
	
	return noidea_str;
}

float noidea_node2float(NOIDEA_node * noidea_nud)
{
	char * noidea_str = noidea_nud->pack;
	int noidea_format;
	int noidea_index = 0;
	int noidea_int = 0;
	float noidea_flt = 0;
	int noidea_tmp;
	//make sure its a bin type
	if ((*(noidea_str + noidea_index) != 98)&&(*(noidea_str + noidea_index) != 104)&&(*(noidea_str + noidea_index) != 100))
	{
		return 0;
	}
	if (*(noidea_str + noidea_index) == 98)
	{
		noidea_format = 2;
	}
	if (*(noidea_str + noidea_index) == 104)
	{
		noidea_format = 16;
	}
	if (*(noidea_str + noidea_index) == 100)
	{
		noidea_format = 10;
	}
	noidea_index += sizeof(char);
	//get the sign
	int noidea_sign = 0;
	if (*(noidea_str + noidea_index) == (char)45)
	{
		noidea_sign = 1;
		noidea_index += sizeof(char);
	}
	//get int from str
	while ( (*(noidea_str + noidea_index) != (char)46) && (*(noidea_str + noidea_index) != (char)35) )
	{
		noidea_tmp = noidea_hex2nibble(*(noidea_str + noidea_index));
		noidea_int = noidea_int * noidea_format;
		noidea_int = noidea_int + noidea_tmp;
		noidea_index += sizeof(char);
	}
	//now maybe we got a "."
	int noidea_exp = 0;
	while (*(noidea_str + noidea_index) != 35)
	{
		noidea_tmp = noidea_hex2nibble(*(noidea_str + noidea_index));
		noidea_flt = noidea_flt + (float)noidea_tmp;
		noidea_flt = noidea_flt * noidea_format;
		noidea_exp += 1;
		noidea_index += sizeof(char);
	}
	noidea_flt = noidea_flt / noidea_intpow(noidea_format,noidea_exp);
	//let unite real with float
	noidea_flt += (float)noidea_int;
	if (noidea_sign != 0)
	{
		noidea_flt = 0 - noidea_flt;
	}

	return noidea_flt;
}

char * noidea_nodeadd(NOIDEA_node * noidea_nud1, NOIDEA_node * noidea_nud2,int noidea_format)
{
	return noidea_float2str(noidea_node2float(noidea_nud1) + noidea_node2float(noidea_nud2),noidea_format);
}

char * noidea_nodesub(NOIDEA_node * noidea_nud1, NOIDEA_node * noidea_nud2,int noidea_format)
{
	return noidea_float2str(noidea_node2float(noidea_nud1) - noidea_node2float(noidea_nud2),noidea_format);
}

char * noidea_nodemul(NOIDEA_node * noidea_nud1, NOIDEA_node * noidea_nud2,int noidea_format)
{
	return noidea_float2str(noidea_node2float(noidea_nud1) * noidea_node2float(noidea_nud2),noidea_format);
}

char * noidea_nodediv(NOIDEA_node * noidea_nud1, NOIDEA_node * noidea_nud2,int noidea_format)
{
	return noidea_float2str(noidea_node2float(noidea_nud1) / noidea_node2float(noidea_nud2),noidea_format);
}
//and or not xor shl shr modulo....