stringline.cpp

AliEditor_Source code

	int datatype = 0;

	pos = linestr.Find("UINT32", 0);
	if(!pos)
	{
		datatype = 32;
	}

	if(!datatype)
	{
		pos = linestr.Find("UINT16", 0);
		if(!pos)
		{
			datatype = 16;
		}
	}

	if(!datatype)
	{
		pos = linestr.Find("UINT8", 0);
		if(!pos)
		{
			datatype = 8;
		}
	}

	if(!datatype)
	{
		pos = linestr.Find("char", 0);
		if(!pos)
		{
			datatype = 8;
		}
	}

	if(!datatype)
	{
		pos = linestr.Find("short", 0);
		if(!pos)
		{
			datatype = 16;
		}
	}

	if(!datatype)
	{
		pos = linestr.Find("int", 0);
		if(!pos)
		{
			datatype = 32;
		}
	}

	if(!datatype)
	{
		pos = linestr.Find("long", 0);
		if(!pos)
		{
			datatype = 32;
		}
	}

	if(!datatype)
	{
		pos = linestr.Find("unsigned", 0);
		if(!pos)
		{
			pos = linestr.Find("char", 0);
			if(!pos)
			{
				datatype = 8;
			}

			if(!datatype)
			{
				pos = linestr.Find("short", 0);
				if(!pos)
				{
					datatype = 16;
				}
			}

			if(!datatype)
			{
				pos = linestr.Find("int", 0);
				if(!pos)
				{
					datatype = 32;
				}
			}

			if(!datatype)
			{
				pos = linestr.Find("long", 0);
				if(!pos)
				{
					datatype = 32;
				}
			}

		}
	}
	
	if(!datatype)
	{//sorry, can't find data type
		return NULL;
	}

	if(1)//parse name
	{
		//parse var name now
		pos = FindSpacePos(linestr);
		if(pos <= 0) return NULL;//can't find variable
		
		CString namestr = linestr.Right(linestr.GetLength() - pos - 1);

		pos = FindSpacePos(namestr);
		if(pos > 0)
		{
			CString tempstr = namestr.Right(namestr.GetLength() - pos);

			namestr = namestr.Left(pos);
			
			int spos = tempstr.Find(']');
			if(spos > 0)
			{
				tempstr = tempstr.Left(spos + 1);
				tempstr = FilterFrontChar(tempstr, ' ');

				namestr = namestr + tempstr;
			}
			
		}

		pos = namestr.Find(":", 0);//first find bits id;

		if(pos > 0) namestr = namestr.Left(pos);
		
		if(bComment)
		{
			CommentPos = namestr.Find("/*#", 0);
			if(CommentPos > 0) namestr = namestr.Left(CommentPos);
			else
			{
				;
			}
		}
		else
		{
			;
		}
		
		pos = namestr.Find("[", 0);
		if(pos != -1)
		{
			CString arraystr = namestr.Right(namestr.GetLength() - pos - 1);

			namestr = namestr.Left(pos);

			pos = arraystr.Find(']', 0);
			if(pos == -1) return NULL;

			arraystr = arraystr.Left(pos);
			ArrayNum = GetDigitValue(arraystr);
		}

		namestr = FilterFrontChar(namestr, ' ');
		namestr = FilterBackChar(namestr, ' ');

		if(!name[0]) strcpy(name, (LPCSTR)namestr);
	}

	if(!bits_length)
	{
		CString namestr;

		pos = linestr.Find(":", 0);
		if(pos == -1)
		{
			bits_length = datatype;
		}
		else
		{
			if(bComment)
			{
				CommentPos = linestr.Find("/*#", 0);
				if(CommentPos > pos || CommentPos == -1)
				{
					namestr = linestr.Right(linestr.GetLength() - pos -1);

					bits_length = GetDigitValue((LPCSTR)namestr);
				}
				else
				{
					bits_length = datatype;
				}
			}
			else
			{
				namestr = linestr.Right(linestr.GetLength() - pos -1);

				bits_length = GetDigitValue((LPCSTR)namestr);
			}

		}
	}

	if(!bits_length) return NULL;

	if(tag == NOFIND) tag = DIGIT;

	//well, create new node
	pNodeInfo = new NodeField;
	memset(pNodeInfo, 0, sizeof(NodeField));

	strcpy(pNodeInfo->name, name);

	pNodeInfo->bits_width = bits_length;

	if(bArray) 
	{
		bits_length = datatype * ArrayNum;

		if(tag != STRING) tag = ARRAY;
	}

	pNodeInfo->bits_length = bits_length;

	pNodeInfo->field_mask = bFieldMask;

	pNodeInfo->field_pos = fieldpos;

	pNodeInfo->tag = tag;

	return pNodeInfo;
}

long CStringLines::GetDigitValue(CString str)
{
	int factor;
	int i = 0;
	long lval = 0;

	str = FilterFrontValidChar(str);
	str.MakeLower();
	int pos = str.Find("0x");

	if(!pos)
	{
		factor = 16;
		str.Delete(0, 2);
	}
	else factor = 10;

	for(i = 0; i < str.GetLength(); i++)
	{
		if(!((str.GetAt(i) >= '0' && str.GetAt(i) <= '9') || (str.GetAt(i) >= 'a' && str.GetAt(i) <= 'f')))
			break;
	}

	str = str.Left(i);

	i = 0;
	const char *buf = (LPCSTR)str;

	while(buf[i] && ((buf[i] >= '0' && buf[i] <= '9') || (buf[i] >= 'a' && buf[i] <= 'f')))
	{
		if(buf[i] >= '0' && buf[i] <= '9')
		{
			lval = lval * factor + buf[i] - '0';
		}
		else if(buf[i] >= 'a' && buf[i] <= 'f')
		{
			lval = lval * factor + buf[i] - 'a' + 10;
		}
		
		i++;
	};
	
	return lval;
}

NodeField** CStringLines::ParseNodeField(enum NodeType type, const char* buf)
{
	if(type == TP_NODE)
	{
		if(m_tp_node) FreeNodeFieldInfo(m_tp_node);

		m_tp_node = ParseNodeField("/*#tp_node@*/", buf);

		return m_tp_node;
	}
	if(type == SAT_NODE)
	{
		if(!m_sat_node) FreeNodeFieldInfo(m_sat_node);

		m_sat_node = ParseNodeField("/*#sat_node@*/", buf);

		return m_sat_node;
	}
	if(type == PROG_NODE)
	{
		if(!m_prog_node) FreeNodeFieldInfo(m_prog_node);

		m_prog_node = ParseNodeField("/*#prog_node@*/", buf);

		return m_prog_node;
	}

	if(type == DEF_PROG_NODE)
	{
		if(!m_prog_node) FreeNodeFieldInfo(m_prog_node);

		m_prog_node = ParseNodeField("/*#prog_node@*/", buf);

		return m_prog_node;
	}

	return NULL;
}

NodeField**CStringLines::GetNodeFieldInfo(enum NodeType type, BOOL bFull)
{
	if(type == TP_NODE)
	{
		if(bFull) return m_tp_full_node;
		else return m_tp_node;
	}
	if(type == SAT_NODE)
	{
		if(bFull) return m_sat_full_node;
		else return m_sat_node;
	}
	if(type == PROG_NODE)
	{
		if(bFull) return m_prog_full_node;
		else return m_prog_node;
	}

	if(type == DEF_PROG_NODE)
	{
		return m_def_prog_full_node;
	}

	return NULL;
}

void CStringLines::FreeNodeFieldInfo(enum NodeType type)
{
	if(type == TP_NODE)
	{
		if(m_tp_node) FreeNodeFieldInfo(m_tp_node);
		if(m_tp_full_node) FreeNodeFieldInfo(m_tp_full_node);

		m_tp_node = NULL;
		m_tp_full_node = NULL;

		m_tp_field_count = 0;
		m_tp_field_full_count = 0;
	}
	if(type == SAT_NODE)
	{
		if(m_sat_node) FreeNodeFieldInfo(m_sat_node);
		if(m_sat_full_node) FreeNodeFieldInfo(m_sat_full_node);

		m_sat_node = NULL;
		m_sat_full_node = NULL;

		m_sat_field_count = 0;
		m_sat_field_full_count = 0;
	}
	if(type == PROG_NODE)
	{
		if(m_prog_node) FreeNodeFieldInfo(m_prog_node);
		if(m_prog_full_node) FreeNodeFieldInfo(m_prog_full_node);

		m_prog_node = NULL;
		m_prog_full_node = NULL;

		m_prog_field_count = 0;
		m_prog_field_full_count = 0;
	}
	if(type == DEF_PROG_NODE)
	{
		if(m_def_prog_full_node) FreeNodeFieldInfo(m_def_prog_full_node);

		m_def_prog_full_node = NULL;

		m_def_prog_field_full_count = 0;
	}
}

int CStringLines::GetNodeFieldCount(enum NodeType type, const char *buf)
{
	if(type == TP_NODE)
	{
		if(!m_tp_field_full_count) m_tp_field_full_count = GetNodeFieldCount("/*#tp_node@*/", buf);

		return m_tp_field_full_count;
	}
	if(type == SAT_NODE)
	{
		if(!m_sat_field_full_count) m_sat_field_full_count = GetNodeFieldCount("/*#sat_node@*/", buf);

		return m_sat_field_full_count;
	}
	if(type == PROG_NODE)
	{
		if(!m_prog_field_full_count) m_prog_field_full_count = GetNodeFieldCount("/*#prog_node@*/", buf);

		return m_prog_field_full_count;
	}

	return 0;
}

int CStringLines::GetNodeFieldCount(enum NodeType type)
{
	int count = 0;

	if(type == TP_NODE)
	{
		if(m_tp_field_count) return m_tp_field_count;
		
		while(m_tp_node[count]) count++;

		m_tp_field_count = count;

		return m_tp_field_count;
	}
	if(type == SAT_NODE)
	{
		if(m_sat_field_count) return m_sat_field_count;
		
		while(m_sat_node[count]) count++;

		m_sat_field_count = count;

		return m_sat_field_count;
	}
	if(type == PROG_NODE)
	{
		if(m_prog_field_count) return m_prog_field_count;
		
		while(m_prog_node[count]) count++;

		m_prog_field_count = count;

		return m_prog_field_count;
	}

	if(type == DEF_PROG_NODE)
	{
		if(m_def_prog_field_full_count) return m_def_prog_field_full_count;
		
		while(m_def_prog_full_node[count]) count++;

		m_def_prog_field_full_count = count;

		return m_def_prog_field_full_count;
	}
	
	return 0;
}

int CStringLines::GetUnMaskFieldCount(enum NodeType type)
{
	int count;
	int unmasked;
	NodeField** pNode = GetNodeFieldInfo(type);
	if(!pNode) return 0;

	count = 0;
	unmasked = 0;

	count = GetNodeFieldCount(type);
	for(int i = 0; i < count; i++)
	{
		if(!pNode[i]) break;

		if(!pNode[i]->field_mask) unmasked++;
	}

	return unmasked;
}

int CStringLines::GetNodeSize(enum NodeType type)
{
	NodeField **pNode = NULL;

	if(type == TP_NODE)
	{
		pNode = m_tp_full_node;
	}
	if(type == SAT_NODE)
	{
		pNode = m_sat_full_node;
	}
	if(type == PROG_NODE)
	{
		pNode = m_prog_full_node;
	}
	if(type == DEF_PROG_NODE)
	{
		pNode = m_def_prog_full_node;
	}

	if(!pNode) return 0;

	int i = 0;
	int bits_all = 0;

	while(pNode[i])
	{
		bits_all += pNode[i]->bits_length;
		i++;
	}

	if(bits_all % 8 != 0)
	{
		ASSERT(0);

		return 0;
	}

	bits_all = bits_all / 8;


	return bits_all;
}

#define MAX_LIMITED 1024

NodeField** CStringLines::ReadOneNodeFieldFromScript(FILE *fd, const char*nodesz)
{
	int val;
	int reads;
	short length, count;
	NodeField**pField = NULL;

	count = 0;

	reads = fread(&count, 1, sizeof(count), fd);
	if(reads != sizeof(count)) return NULL;

	pField = new NodeField*[count + 1];
	if(!pField) return NULL;

	memset(pField, 0, sizeof(NodeField*) * (count + 1));

#ifdef _MY_DEBUG

	fprintf(scriptfd, "\r\nbegin parse script file...\r\n");
	fprintf(scriptfd, "\tNode type : %s\r\n", nodesz);
#endif

	for(int i = 0; i < count; i++)
	{
		pField[i] = new NodeField;
		if(!pField[i]) return NULL;

		//first name
		reads = fread(&length, 1, sizeof(length), fd);
		if(reads != sizeof(length)) goto FAILED;

		if(length < 0 || length >= sizeof(pField[i]->name)) goto FAILED;

		reads = fread(pField[i]->name, 1, length, fd);
		if(reads != length) goto FAILED;

		pField[i]->name[length] = 0;

		//tag
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->tag = (enum DataType)val;

		//mask
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->field_mask = val;

		//pos
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->field_pos = val;

		//bits width
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->bits_width = val;
	
		//bits length
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->bits_length = val;

		//bits offset
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->bits_offset = val;

		//bytes offset
		reads = fread(&val, 1, sizeof(int), fd);//4
		if(reads != sizeof(int)) goto FAILED;
		pField[i]->bytes_offset = val;

#ifdef _MY_DEBUG

			fprintf(scriptfd, "name : %24s, tag : %d, length : %2d, bits : %2d, bytes: %2d, masked : %1d\r\n",
				pField[i]->name, pField[i]->tag, pField[i]->bits_length, pField[i]->bits_offset,
				pField[i]->bytes_offset, pField[i]->field_mask);
#endif
	}

#ifdef _MY_DEBUG

			fprintf(scriptfd, "end parse script file...\r\n");
#endif

	return pField;

FAILED:
	
	FreeNodeFieldInfo(pField);

	return NULL;
}

BOOL CStringLines::ReadNodeFieldFromScript(FILE *fd)
{
	int reads;
	int count, UsedCount;
	short length;
	char bufsz[MAX_LIMITED];
	NodeField**pField = NULL;
	NodeField**pUsedField = NULL;

	while(!feof(fd))
	{
		reads = fread(&length, 1, sizeof(length), fd);
		if(reads != sizeof(length)) return FALSE;
		if(length <= 0 || length >= MAX_LIMITED) return FALSE;
		reads = fread(&bufsz, 1, length, fd);
		if(reads != length) return FALSE;
		bufsz[length] = 0;

		pField = ReadOneNodeFieldFromScript(fd, bufsz);
		if(!pField) return FALSE;

		count = 0;
		while(pField[count]) count++;

		pUsedField = AdjustNodeField(pField);

		UsedCount = 0;
		while(pField[UsedCount]) UsedCount++;

		if(!strcmp(bufsz, "/*#tp_node@*/"))
		{
			if(m_tp_full_node) FreeNodeFieldInfo(m_tp_full_node);
			m_tp_full_node = pField;
			m_tp_field_full_count = count;
/*
			CString str;
			str.Format("read tp count : %d", count);
			AfxMessageBox(str);
*/
			if(m_tp_node) FreeNodeFieldInfo(m_tp_node);
			m_tp_node = pUsedField;	
			m_tp_field_count = UsedCount;
		}
		else if(!strcmp(bufsz, "/*#sat_node@*/"))
		{
			if(m_sat_full_node) FreeNodeFieldInfo(m_sat_full_node);
			m_sat_full_node = pField;
			m_sat_field_full_count = count;
/*
			CString str;
			str.Format("read sat count : %d", count);
			AfxMessageBox(str);
*/
			if(m_sat_node) FreeNodeFieldInfo(m_sat_node);
			m_sat_node = pUsedField;
			m_sat_field_count = UsedCount;
		}
		else if(!strcmp(bufsz, "/*#prog_node@*/"))
		{
			if(m_prog_full_node) FreeNodeFieldInfo(m_prog_full_node);
			m_prog_full_node = pField;
			m_prog_field_full_count = count;

/*			CString str;
			str.Format("read prog count : %d", count);
			AfxMessageBox(str);*/

			if(m_prog_node) FreeNodeFieldInfo(m_prog_node);
			m_prog_node = pUsedField;
			m_prog_field_count = UsedCount;
		}
		else if(!strcmp(bufsz, "/*#def_prog_node@*/"))
		{
			if(m_def_prog_full_node) FreeNodeFieldInfo(m_def_prog_full_node);
			m_def_prog_full_node = pField;
			m_def_prog_field_full_count = count;

			FreeNodeFieldInfo(pUsedField);//free it

/*			CString str;
			str.Format("read prog count : %d", count);
			AfxMessageBox(str);*/
		}

	};

	return TRUE;
}

BOOL CStringLines::WriteOneNodeFieldToScript(FILE *fd, NodeField**pField)
{
	int i, val;
	short length;

	i = 0;

	while(pField[i])
	{
		//first name
		length = strlen(pField[i]->name);

		fwrite(&length, 1, sizeof(length), fd);
		fwrite(pField[i]->name, 1, length, fd);

		//tag
		val = (int)pField[i]->tag;
		fwrite(&val, 1, sizeof(int), fd);//4

		//mask
		val = (int)pField[i]->field_mask;
		fwrite(&val, 1, sizeof(int), fd);//4

		//pos
		val = (int)pField[i]->field_pos;
		fwrite(&val, 1, sizeof(int), fd);//4

		//bits width
		val = (int)pField[i]->bits_width;
		fwrite(&val, 1, sizeof(int), fd);//4

		//bits length
		val = (int)pField[i]->bits_length;
		fwrite(&val, 1, sizeof(int), fd);//4

		//bits offset
		val = (int)pField[i]->bits_offset;
		fwrite(&val, 1, sizeof(int), fd);//4

		//bytes offset
		val = (int)pField[i]->bytes_offset;
		fwrite(&val, 1, sizeof(int), fd);//4

		i++;
	};

	return TRUE;
}

BOOL CStringLines::WriteNodeFieldToScript(FILE *fd)
{
	short length;
	char bufsz[64];

	if(!m_tp_full_node || !m_sat_full_node || !m_prog_full_node) return FALSE;

	if(m_tp_full_node)
	{
		sprintf(bufsz, "%s", "/*#tp_node@*/");
		length = strlen(bufsz);
		
		fwrite(&length, 1, sizeof(length), fd);
		fwrite(bufsz, 1, length, fd);
/*
		{
			CString str;
			str.Format("write tp count : %d", length);
			AfxMessageBox(str);
		}
		*/
		length = m_tp_field_full_count;
		fwrite(&length, 1, sizeof(length), fd);

		WriteOneNodeFieldToScript(fd, m_tp_full_node);
	}

	if(m_sat_full_node)
	{
		sprintf(bufsz, "%s", "/*#sat_node@*/");
		length = strlen(bufsz);
		
		fwrite(&length, 1, sizeof(length), fd);
		fwrite(bufsz, 1, length, fd);

		length = m_sat_field_full_count;
/*
		CString str;
			str.Format("write sat count : %d", length);
			AfxMessageBox(str);
*/
		fwrite(&length, 1, sizeof(length), fd);

		WriteOneNodeFieldToScript(fd, m_sat_full_node);
	}


	if(m_prog_full_node)
	{
		sprintf(bufsz, "%s", "/*#prog_node@*/");
		length = strlen(bufsz);
		
		fwrite(&length, 1, sizeof(length), fd);
		fwrite(bufsz, 1, length, fd);

		length = m_prog_field_full_count;
		fwrite(&length, 1, sizeof(length), fd);
/*
		CString str;
			str.Format("write prog count : %d", length);
			AfxMessageBox(str);
*/
		WriteOneNodeFieldToScript(fd, m_prog_full_node);
	}

	if(m_def_prog_full_node)
	{
		sprintf(bufsz, "%s", "/*#def_prog_node@*/");
		length = strlen(bufsz);
		
		fwrite(&length, 1, sizeof(length), fd);
		fwrite(bufsz, 1, length, fd);

		length = GetNodeFieldCount(DEF_PROG_NODE);
		fwrite(&length, 1, sizeof(length), fd);
/*
		CString str;
			str.Format("write prog count : %d", length);
			AfxMessageBox(str);
*/
		WriteOneNodeFieldToScript(fd, m_def_prog_full_node);
	}

	return TRUE;
}