dbparser.cpp

AliEditor_Source code

		ASSERT(bRet);

		pdbheader->precord[i] = free_addr;

		free_addr = free_addr + sat_node_size;
	}

	pdbheader  = &m_tpheader;//for tp node
	
	for(i = 0; i < pdbheader->rec_length; i++)
	{
		if(pdbheader->precord[i] == -1) continue;

		bRet = UnpackNode(TP_NODE, backup_buf + free_addr, pdatabuf + pdbheader->precord[i]);
		ASSERT(bRet);

		pdbheader->precord[i] = free_addr;

		free_addr = free_addr + tp_node_size;
	}

	pdbheader  = &m_progheader;//for prog node
	
	int nOrder = 0;
	for(i = 0; i < pdbheader->rec_length; i++)
	{
		if(pdbheader->precord[i] == -1) continue;

		if( i == 319 )
			nOrder++;

		bRet = UnpackNode(PROG_NODE, backup_buf + free_addr, pdatabuf + pdbheader->precord[i]);
		ASSERT(bRet);

		pdbheader->precord[i] = free_addr;	

		free_addr = free_addr + prog_node_size;
	}

	if(m_limited_len < free_addr)
	{
		AfxMessageBox("DB4 to DB3 Transfer : Out of Range");

		delete backup_buf;

		return FALSE;
	}

	m_free_addr = free_addr;

	memcpy(pdatabuf, backup_buf, m_free_addr);

	delete []backup_buf;	
	return TRUE;
}

BOOL CDbParser::UnpackNode(enum NodeType type, char *des, char *src)
{
	int i = 0;
	BOOL bRet;
	int index = 0;

	UINT32 node_id = 0;
	int offset = 0;
	int length = 0;

	char bufsz[128];
	if(!des || !src) return FALSE;

	char *pdes = des;
	char *psrc = src;

	CStringLines *pScripter = &((CMainFrame*)AfxGetMainWnd())->GetEditorView()->m_strlines;
	NodeField **pNodeField = pScripter->GetNodeFieldInfo(type, TRUE);
	if(!pNodeField) return FALSE;
	
	int iret = GetNodeFixedInfo(type, offset, length);
	ASSERT(!iret);

	memcpy((UINT8 *)&node_id, psrc, NODE_ID_SIZE);
	
	psrc += NODE_ID_SIZE + 1; // ID size + 1 byte len
	pdes += offset;

	memcpy(pdes, psrc, length);

	psrc += length;
	pdes += length;

	while(pNodeField[i])
	{
		if(!strcmp(pNodeField[i]->name, KEYZ_SAT_ID))
		{
			//sprintf(bufsz, "%d", (UINT16)(node_id>>(NODE_ID_PG_BIT+NODE_ID_TP_BIT)));
			sprintf(bufsz, "%d", ((node_id & SET_BIT_MASK) >> (NODE_ID_TP_BIT+NODE_ID_PG_BIT))); 

			bRet = SetNodeInfo(type, des, i, bufsz);
			ASSERT(bRet);

		}
		if(!strcmp(pNodeField[i]->name, KEYZ_TP_ID))
		{
			//sprintf(bufsz, "%d", (UINT16)(node_id>>NODE_ID_PG_BIT));
			sprintf(bufsz, "%d", ((node_id & TP_BIT_MASK) >> NODE_ID_PG_BIT));

			bRet = SetNodeInfo(type, des, i, bufsz);
			ASSERT(bRet);
		}
		
		if(!strcmp(pNodeField[i]->name, KEYZ_PROG_ID))
		{
			sprintf(bufsz, "%d", node_id & PG_BIT_MASK);

			bRet = SetNodeInfo(type, des, i, bufsz);
			ASSERT(bRet);
		}

		if(!strcmp(pNodeField[i]->name, PKEYZ_AUDIO_COUNT))
		{
			//memcpy(pdes, psrc, 2);

			UINT16 audio_count = (UINT16)psrc[0];
			memcpy(pdes, &audio_count, 2);

			pdes += 2;
			psrc += 1;

			index = GetIndexOfNodeInfo(pNodeField, PKEYZ_AUDIO_LANG);
			ASSERT(index != -1);

			memset(pdes, 0, pNodeField[index]->bits_length / 8);

			memcpy(pdes, psrc, audio_count * 2);
			psrc += audio_count * 2;
			pdes += (pNodeField[index]->bits_length / 8);

			memset(pdes, 0, pNodeField[index]->bits_length / 8);

			memcpy(pdes, psrc, audio_count * 2);
			psrc += audio_count * 2;
			pdes += (pNodeField[index]->bits_length / 8);
		}

		if(!strcmp(pNodeField[i]->name, PKEYZ_NAME_LEN))
		{
			//memcpy(pdes, psrc, 2);

			UINT16 name_len = (UINT16)psrc[0];
			memcpy(pdes, &name_len, 2);

			pdes += 2;
			psrc += 1;

			index = GetIndexOfNodeInfo(pNodeField, PKEYZ_SERVICE_NAME);
			if(index == -1) index = GetIndexOfNodeInfo(pNodeField, SKEYZ_SAT_NAME);
			ASSERT(index != -1);

			memset(pdes, 0, pNodeField[index]->bits_length / 8);

			memcpy(pdes, psrc, name_len);
			psrc += name_len;
			pdes += (pNodeField[index]->bits_length / 8);
		}

		if(!strcmp(pNodeField[i]->name, PKEYZ_PROVIDER_NAME_LEN))
		{
			//memcpy(pdes, psrc, 2);

			UINT16 name_len = (UINT16)psrc[0];
			memcpy(pdes, &name_len, 2);

			pdes += 2;
			psrc += 1;

			index = GetIndexOfNodeInfo(pNodeField, PKEYZ_SERVICE_PROVIDER_NAME);
			ASSERT(index != -1);

			memset(pdes, 0, pNodeField[index]->bits_length / 8);

			memcpy(pdes, psrc, name_len);
			psrc += name_len;
			pdes += (pNodeField[index]->bits_length / 8);
		}

	
		i++;
	}

	return TRUE;
}

BOOL CDbParser::PackNode(enum NodeType type, char *des, char *src, int *pDesLen)
{
	int i = 0;
	BOOL bRet;
	int index = 0;

	UINT32 node_id = 0;
	int offset = 0;
	int length = 0;

	char bufsz[128];
	if(!des || !src || !pDesLen) return FALSE;

	char *pdes = des;
	char *psrc = src;
	*pDesLen = 0;

	CStringLines *pScripter = &((CMainFrame*)AfxGetMainWnd())->GetEditorView()->m_strlines;
	NodeField **pNodeField = pScripter->GetNodeFieldInfo(type, TRUE);
	if(!pNodeField) return FALSE;
	
	int iret = GetNodeFixedInfo(type, offset, length);
	ASSERT(!iret);

//	memcpy((UINT8 *)&node_id, psrc, NODE_ID_SIZE);
	
	psrc += offset;//4;
	pdes += NODE_ID_SIZE + 1;//offset; id size + 1 byte len
	*pDesLen += NODE_ID_SIZE + 1;

	memcpy(pdes, psrc, length);

	psrc += length;
	pdes += length;
	*pDesLen += length;

	while(pNodeField[i])
	{
		if(!strcmp(pNodeField[i]->name, "audio_channel"))
		{
#ifdef DEFAULT_AUDIO_STEREO
			sprintf(bufsz, "%d", 2); 
			bRet = SetNodeInfo(type, des-7, i, bufsz);
			ASSERT(bRet);
#endif
		}
		if(!strcmp(pNodeField[i]->name, KEYZ_SAT_ID))
		{
			bRet = GetNodeInfo(type, src, i, bufsz);
			ASSERT(bRet);		
			UINT32 bySataId =	GetDataValue(bufsz);
			//node_id = bySataId << (NODE_ID_TP_BIT+NODE_ID_PG_BIT);
			node_id |= ( bySataId << (NODE_ID_PG_BIT + NODE_ID_TP_BIT) );
		}
		if(!strcmp(pNodeField[i]->name, KEYZ_TP_ID))
		{
			bRet = GetNodeInfo(type, src, i, bufsz);
			ASSERT(bRet);		
			UINT32 bySataId =	GetDataValue(bufsz);			
//#if defined(DB_LARGE_MEM_MODE)
//			UINT32 nIDSat = bySataId & 0x0000FF00; 
//			UINT32 nIDTp = bySataId & 0x000000FF;
//			node_id = (nIDSat << 12) | (nIDTp << 10);
//#else
//			node_id = bySataId << NODE_ID_TP_BIT;
//#endif
			node_id |=  (bySataId << NODE_ID_PG_BIT);
		}
		
		if(!strcmp(pNodeField[i]->name, PKEYZ_PROG_ID))
		{
			bRet = GetNodeInfo(type, src, i, bufsz);
			ASSERT(bRet);		
			UINT32 bySataId =	GetDataValue(bufsz);
			node_id |= bySataId;
		}

		if(!strcmp(pNodeField[i]->name, PKEYZ_AUDIO_COUNT))
		{
			UINT8 audio_count = psrc[0];
			memcpy(pdes, &audio_count, 1);			
			psrc += 2;
			pdes += 1;
			*pDesLen += 1;

			index = GetIndexOfNodeInfo(pNodeField, PKEYZ_AUDIO_LANG);
			ASSERT(index != -1);

			memset(pdes, 0, audio_count * 2);
			memcpy(pdes, psrc, audio_count * 2);
			psrc += (pNodeField[index]->bits_length / 8);
			pdes += audio_count * 2;
			*pDesLen += audio_count * 2;

			memset(pdes, 0, audio_count * 2);
			memcpy(pdes, psrc, audio_count * 2);
			psrc += (pNodeField[index]->bits_length / 8);
			pdes += audio_count * 2;
			*pDesLen += audio_count * 2;
		}

		if(!strcmp(pNodeField[i]->name, PKEYZ_NAME_LEN))
		{
			UINT8 name_len = (UINT8)psrc[0];
			memcpy(pdes, &name_len, 1);

			psrc += 2;
			pdes += 1;
			*pDesLen += 1;			

			index = GetIndexOfNodeInfo(pNodeField, PKEYZ_SERVICE_NAME);
			if(index == -1) index = GetIndexOfNodeInfo(pNodeField, SKEYZ_SAT_NAME);
			ASSERT(index != -1);

			memset(pdes, 0, name_len);
			memcpy(pdes, psrc, name_len);
			psrc += (pNodeField[index]->bits_length / 8);
			pdes += name_len;
			*pDesLen += name_len;
		}

		if(!strcmp(pNodeField[i]->name, PKEYZ_PROVIDER_NAME_LEN))
		{
			UINT8 name_len = (UINT8)psrc[0];
			memcpy(pdes, &name_len, 1);

			psrc += 2;
			pdes += 1;
			*pDesLen += 1;			

			index = GetIndexOfNodeInfo(pNodeField, PKEYZ_SERVICE_PROVIDER_NAME);
			ASSERT(index != -1);

			memset(pdes, 0, name_len);
			memcpy(pdes, psrc, name_len);
			psrc += (pNodeField[index]->bits_length / 8);
			pdes += name_len;
			*pDesLen += name_len;
		}

	
		i++;
	}
	memcpy(des, &node_id, sizeof(UINT32));
	unsigned char *packnode_len = (unsigned char*)(des + 4);
	*packnode_len = (unsigned char)(*pDesLen - 4);
	return TRUE;
}

//仅仅在内存中调整用户数据库
BOOL CDbParser::RearrageDatabase()
{
	int i;//, tmp_addr;
	int prog_node_size, tp_node_size, sat_node_size;
	
	char *pdatabuf = m_pdatabuf;
	if(!pdatabuf) return FALSE;

	CStringLines *pScripter = &((CMainFrame*)AfxGetMainWnd())->GetEditorView()->m_strlines;
	tp_node_size = pScripter->GetNodeSize(TP_NODE);
	sat_node_size = pScripter->GetNodeSize(SAT_NODE);
	prog_node_size = pScripter->GetNodeSize(PROG_NODE);

	if(!tp_node_size || !sat_node_size || !prog_node_size) return FALSE;

	char *backup_buf = new char[DATA_LIMIT_LEN];
	if(!backup_buf) return FALSE;
	
	memset(backup_buf, -1, DATA_LIMIT_LEN);

	db_header_t *pdbheader  = &m_satheader;//for sat node

	int free_addr = 0;

	//skip -1
	for(i = 0; i < pdbheader->rec_length; i++)
	{
		if(pdbheader->precord[i] == -1) continue;

		memcpy(backup_buf + free_addr, pdatabuf + pdbheader->precord[i], sat_node_size);

		pdbheader->precord[i] = free_addr;

		free_addr = free_addr + sat_node_size;
	}

	pdbheader  = &m_tpheader;//for tp node
	
	for(i = 0; i < pdbheader->rec_length; i++)
	{
		if(pdbheader->precord[i] == -1) continue;
		
		memcpy(backup_buf + free_addr, pdatabuf + pdbheader->precord[i], tp_node_size);

		pdbheader->precord[i] = free_addr;

		free_addr = free_addr + tp_node_size;
	}

	pdbheader  = &m_progheader;//for prog node
	
	int nOrder = 0;
	for(i = 0; i < pdbheader->rec_length; i++)
	{
		if(pdbheader->precord[i] == -1) continue;

		memcpy(backup_buf + free_addr, pdatabuf + pdbheader->precord[i], prog_node_size);

		pdbheader->precord[i] = free_addr;

		free_addr = free_addr + prog_node_size;
	}

	if(m_limited_len < free_addr)
	{
		AfxMessageBox("Rearrage : Out of Range");

		delete backup_buf;

		return FALSE;
	}

	m_free_addr = free_addr;

	memcpy(pdatabuf, backup_buf, m_limited_len);

	delete []backup_buf;

	return TRUE;
}

int  CDbParser::GetNodeFixedInfo(enum NodeType type, int &offset, int &length)
{
	CStringLines *pScripter = &((CMainFrame*)AfxGetMainWnd())->GetEditorView()->m_strlines;
	NodeField **pNode = pScripter->GetNodeFieldInfo(type, TRUE);
	if(!pNode) return -1;

	offset = 0;
	int i = 0;
	int bits_all = 0;

	while(pNode[i])
	{
		if(!strcmp(pNode[i]->name, PKEYZ_AUDIO_COUNT))
			break;
		if(!strcmp(pNode[i]->name, PKEYZ_NAME_LEN))
			break;
		if(!strcmp(pNode[i]->name, PKEYZ_PROVIDER_NAME_LEN))
			break;

		if(!strcmp(pNode[i]->name, KEYZ_SAT_ID))
		{
			offset += 4;
			i++; continue;
		}
		if(!strcmp(pNode[i]->name, KEYZ_TP_ID))
		{
			offset += 4;
			i++; continue;
		}
		if(!strcmp(pNode[i]->name, PKEYZ_PROG_ID))
		{
			offset += 4;
			i++; continue;
		}

		bits_all += pNode[i]->bits_length;
		i++;
	}

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

		return 0;
	}

	length = bits_all / 8;

	return 0;
}

int CDbParser::GetNodeSize(enum NodeType type)
{
	CStringLines *pScripter = &((CMainFrame*)AfxGetMainWnd())->GetEditorView()->m_strlines;
	return pScripter->GetNodeSize(type);
}
#define REVERT_16(A) (((A & 0xff) << 8) | ((A & 0xff00) >> 8))
BOOL CDbParser::MultiBytesToWideChar(unsigned short * to, char *from, int count)
{
	if(!to || !from || !count) return FALSE;

	memset(to, 0, count);

	int sLen = strlen(from);

	int size = MultiByteToWideChar(CP_ACP, 0, from, sLen, (unsigned short *)to, (count-2)/2 );
	//if(!size) return FALSE;

	for(int i = 0; i < count / 2; i++)
	{
		if(!to[i]) break;

		to[i] = REVERT_16(to[i]);
	}

	return TRUE;
}
//数据库中的Data与标准的Unicode字节相反，转换前需要调整
BOOL CDbParser::WideCharToMultiBytes(char *to, unsigned short *from, int count)
{
	if(!to || !from || !count) return FALSE;

	unsigned short tmpbuf[64];
	memcpy(tmpbuf, from, count);

	for(int i = 0; i < count / 2; i++)
	{
		if(!tmpbuf[i]) break;