DynAry<unsigned int> TokParser::GetUIntStream()
{
DynAry<unsigned int> result;
if(!Ok())
return result;
if(IsTok("{")) {
ExpectTok("{");
while(Ok() && !IsTok("}")) {
result.push_back(GetUInt());
}
ExpectTok("}");
} else {
result.push_back(GetUInt());
}
return result;
}
static void ProcFile( FILE *fp )
/******************************/
{
byte hdr[ 3 ];
unsigned_16 page_len;
unsigned_32 offset;
page_len = 0;
RecBuff = NULL;
RecMaxLen = 0;
for(;;) {
offset = ftell( fp );
if( fread( hdr, 1, 3, fp ) != 3 )
break;
RecLen = hdr[ 1 ] | ( hdr[ 2 ] << 8 );
ResizeBuff( RecLen );
RecPtr = RecBuff;
if( fread( RecBuff, RecLen, 1, fp ) == 0 )
break;
RecLen--;
isMS386 = hdr[ 0 ] & 1;
switch( hdr[ 0 ] & ~1 ) {
case CMD_MODEND:
if( page_len != 0 ) {
offset = ftell( fp );
offset = page_len - offset % page_len;
if( offset != page_len ) {
fseek( fp, offset, SEEK_CUR );
}
}
break;
case CMD_PUBDEF:
if( ( GetIndex() | GetIndex() ) == 0 )
GetUInt();
while( ! EndRec() ) {
GetName();
*RecPtr = 0;
printf( "%s\n", NamePtr );
GetOffset();
GetIndex();
}
break;
case LIB_HEADER_REC:
if( isMS386 ) {
fseek( fp, 0L, SEEK_END );
page_len = 0;
} else {
page_len = RecLen + 4;
}
break;
default:
break;
}
}
free( RecBuff );
}
bool XMLUtils::GetUInt(const TiXmlNode* pRootNode, const char* strTag, uint32_t &value, const uint32_t min, const uint32_t max)
{
if (GetUInt(pRootNode, strTag, value))
{
if (value < min) value = min;
if (value > max) value = max;
return true;
}
return false;
}
unsigned_32 GetEither( void )
/***************************/
{
unsigned_32 value;
if( IsPharLap || IsMS386 ) {
value = GetLInt();
} else {
value = GetUInt();
}
return( value );
}
/*!
* \brief 功能概述 获取报文类型
* \param 参数描述 无
* \return 返回值描述 返回报文类型
* \author zzy
* \date 2015/5/25
*/
int CIEC104Response::GetFrameType()
{
BYTE nControlByte1 = GetUInt(2,1);
switch(nControlByte1&3)
{
case 1:
return IEC104_S_TYPE;
case 3:
return IEC104_U_TYPE;
default:
return IEC104_I_TYPE;
}
}
unsigned_32 GetVariable( void )
/*****************************/
{
byte index;
unsigned_32 size;
unsigned_16 lo;
index = GetByte();
if( index <= COMDEF_LEAF_SIZE ) {
size = index;
} else if( index == COMDEF_LEAF_2 ) {
size = GetUInt();
} else if( index == COMDEF_LEAF_3 ) {
lo = GetUInt();
size = lo + ( (unsigned_32)GetByte() << 16 );
} else if( index == COMDEF_LEAF_4 ) {
size = GetLInt();
} else {
Output( BAILOUT "Unknown COMDEF LEAF size (%b)" CRLF, index );
longjmp( BailOutJmp, 1 );
}
return( size );
}
int CIEC104DeliverQuery::GetFrameType()
{
//获取帧类型
BYTE nControlByte1 = GetUInt(2,1);
if (nControlByte1 == 0xFF)
{
return IEC104_Start_TYPE;
}
switch(nControlByte1&3)
{
case 1:
return IEC104_S_TYPE;
case 3:
return IEC104_U_TYPE;
default:
return IEC104_I_TYPE;
}
}
/*!
* \brief 功能概述 获取帧的名字
* \param 参数描述 无
* \return 返回值描述 返回帧的名字
* \author zzy
* \date 2015/5/25
*/
QString CIEC104Response::GetFrameName()
{
BYTE nControlByte1 = GetUInt(2,1);
QString strTemp;
switch(nControlByte1&3)
{
case 1:
//m_strFrameName = "S帧";
strTemp = QString("S帧 Recieve %1").arg(GetReceiveFrameNo());
break;
case 3:
strTemp = "U帧";
break;
default:
//m_strFrameName = "I帧";
strTemp = QString("I帧 Recieve %1,Send %2").arg(GetReceiveFrameNo()).arg(GetSendFrameNo());
break;
}
m_strFrameName = "(" + strTemp + ")";
return m_strFrameName;
}
int read_registers(const struct ca_segment* segment, struct reg_value* regs, int bufsz)
{
int ptr_sz = g_ptr_bit >> 3;
if (regs)
{
if (bufsz >= TOTAL_REGS)
{
thread_context* lpThreadContext = (thread_context*) segment->m_thread.context;
for (int i=0; i<TOTAL_REGS; i++)
{
unsigned long r_val = ptr_sz == 8 ? GetULong(&lpThreadContext->pr_reg[i]) : GetUInt(&lpThreadContext->pr_reg[i]);
regs[i].reg_num = i;
regs[i].reg_width = ptr_sz;
regs[i].value = (address_t) r_val;
}
return TOTAL_REGS;
}
}
else
return TOTAL_REGS;
return 0;
}
CA_BOOL search_registers(const struct ca_segment*segment,
struct CA_LIST* targets,
struct CA_LIST* refs)
{
int ptr_sz = g_ptr_bit >> 3;
if (segment->m_type != ENUM_STACK)
return false;
bool lbFound = false;
thread_context* lpThreadContext = (thread_context*) segment->m_thread.context;
for (int i=0; i<TOTAL_REGS; i++)
{
unsigned long r_val = ptr_sz == 8 ? GetULong(&lpThreadContext->pr_reg[i]) : GetUInt(&lpThreadContext->pr_reg[i]);
struct object_range* target;
ca_list_traverse_start(targets);
while ( (target = (struct object_range*) ca_list_traverse_next(targets)) )
{
if (r_val >= target->low && r_val < target->high)
{
struct object_reference* ref = (struct object_reference*) malloc(sizeof(struct object_reference));
ref->storage_type = ENUM_REGISTER;
ref->where.reg.tid = segment->m_thread.tid;
ref->where.reg.reg_num = i;
ref->where.reg.name = reg_names[i];
ref->vaddr = 0;
ref->value = r_val;
ca_list_push_back(refs, ref);
lbFound = CA_TRUE;
break;
}
}
}
return lbFound;
}
// Read an UINT from the ini file, increase it and then write it back to the ini file
BOOL CIni::IncreaseUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nIncrease, int nBase) const
{
UINT nVal = GetUInt(lpSection, lpKey, 0, nBase);
nVal += nIncrease;
return WriteUInt(lpSection, lpKey, nVal, nBase);
}
static void ProcFileModRef( FILE *fp )
/************************************/
{
byte hdr[ 3 ];
unsigned_16 page_len;
unsigned_32 offset;
char *module_name;
page_len = 0;
RecBuff = NULL;
RecMaxLen = 0;
module_name = NULL;
for(;;) {
offset = ftell( fp );
if( fread( hdr, 1, 3, fp ) != 3 )
break;
RecLen = hdr[ 1 ] | ( hdr[ 2 ] << 8 );
ResizeBuff( RecLen );
RecPtr = RecBuff;
if( fread( RecBuff, RecLen, 1, fp ) == 0 )
break;
RecLen--;
isMS386 = hdr[ 0 ] & 1;
switch( hdr[ 0 ] & ~1 ) {
case CMD_THEADR:
if( module_name != NULL )
free( module_name );
GetName();
*RecPtr = 0;
module_name = malloc( strlen( (char *)NamePtr ) + 1 );
strcpy( module_name, (char *)NamePtr );
break;
case CMD_MODEND:
if( module_name != NULL )
free( module_name );
module_name = NULL;
if( page_len != 0 ) {
offset = ftell( fp );
offset = page_len - offset % page_len;
if( offset != page_len ) {
fseek( fp, offset, SEEK_CUR );
}
}
break;
case CMD_PUBDEF:
if( ( GetIndex() | GetIndex() ) == 0 )
GetUInt();
while( ! EndRec() ) {
GetName();
*RecPtr = 0;
if( SymbolExists( pubdef_tab, (char *)NamePtr ) != 0 ) {
if( SymbolExists( extdef_tab, module_name ) == 0 ) {
AddSymbol( extdef_tab, module_name, NULL );
printf( "%s\n", module_name );
}
}
GetOffset();
GetIndex();
}
break;
case LIB_HEADER_REC:
if( isMS386 ) {
fseek( fp, 0L, SEEK_END );
page_len = 0;
} else {
page_len = RecLen + 4;
}
break;
default:
break;
}
}
free( RecBuff );
}
static bool InitLinkMap_32(MmapFile& irExec, MmapFile& irCore)
{
char* lpExecStart = irExec.GetStartAddr();
char* lpCoreStart = irCore.GetStartAddr();
char* lpCoreEnd = irCore.GetEndAddr();
Elf32_Ehdr* elfhdr = (Elf32_Ehdr*)lpExecStart;
// search for .dynamic section
Elf32_Dyn* dyn = NULL;
#if defined(linux)
Elf32_Xword dyn_size = 0;
#elif defined(sun)
Elf32_Word dyn_size = 0;
#endif
Elf32_Shdr* shdr = (Elf32_Shdr*)(lpExecStart + elfhdr->e_shoff);
Elf32_Shdr* shstrtbl = shdr + elfhdr->e_shstrndx;
char* shstr = lpExecStart + shstrtbl->sh_offset;
for (int i=0; i < elfhdr->e_shnum; i++)
{
if (0 == strcmp(shstr+shdr->sh_name, ".dynamic")
&& shdr->sh_type == SHT_DYNAMIC)
{
dyn = (Elf32_Dyn*) shdr->sh_addr;
dyn_size = shdr->sh_size;
//printf("Exec's .dynamic section vaddr = 0x%lx\n", dyn);
break;
}
shdr++;
}
if (!dyn)
{
printf("Failed to find Exec's .dynamic\n");
return false;
}
// The content of .dynamic section is in core
Elf32_Dyn* core_dyn = (Elf32_Dyn*) core_to_mmap_addr((address_t)dyn);
if (!core_dyn)
{
printf("Failed to find Exec's .dynamic section in core\n");
return false;
}
// Find the DT_DEBUG entry in the the .dynamic section.
Elf32_Dyn* debug_dyn = NULL;
for (dyn = core_dyn; (char*)dyn - (char*)core_dyn < dyn_size; dyn++)
{
if (GetUInt(&dyn->d_tag) == DT_DEBUG)
{
debug_dyn = dyn;
break;
}
}
if (!debug_dyn)
{
printf("Failed to find debug_dyn\n");
return false;
}
// If the executable's dynamic section has a DT_DEBUG element,
// the run-time linker sets that element's value to the address
// where this struct r_debug (link.h) can be found.
struct r_debug_32* pdebug = (struct r_debug_32*)GetUInt(&debug_dyn->d_un.d_ptr);
pdebug = (struct r_debug_32*) core_to_mmap_addr((address_t)pdebug);
if (!pdebug)
{
printf("Failed to find link map in core\n");
return false;
}
gLinkMap_32 = (struct link_map_32 *) core_to_mmap_addr((address_t)GetUInt(&pdebug->r_map));
if (!gLinkMap_32)
{
printf("Failed to find link map in core\n");
return false;
}
// set executable and library segments.
struct link_map_32 * linkmap = gLinkMap_32;
while (linkmap && (char*)linkmap > lpCoreStart && (char*)linkmap < lpCoreEnd)
{
ca_segment* segment = NULL;
#ifdef sun
address_t load_addr = GetUInt(&linkmap->l_addr);
if (! (segment = get_segment(load_addr, 1) ) )
break;
#endif
Elf32_Dyn* dyn = (Elf32_Dyn*) core_to_mmap_addr((address_t)GetUInt(&linkmap->l_ld));
for (; (char*)dyn >lpCoreStart && (char*)dyn < lpCoreEnd; dyn++)
{
#if defined(linux)
Elf32_Xword tag = GetUInt(&dyn->d_tag);
#elif defined(sun)
Elf32_Sword tag = GetUInt(&dyn->d_tag);
#endif
if (tag == DT_NULL)
break;
#ifdef linux
address_t vaddr = GetUInt(&dyn->d_un.d_ptr);
#elif defined(sun)
address_t vaddr = load_addr + GetUInt(&dyn->d_un.d_ptr);
#endif
if (vaddr)
{
// The segment is likely the same as previous dynamic section
if (!segment || vaddr < segment->m_vaddr || vaddr >= segment->m_vaddr + segment->m_vsize)
segment = get_segment(vaddr, 1);
if (segment && segment->m_type == ENUM_UNKNOWN)
{
if (segment->m_write)
segment->m_type = ENUM_MODULE_DATA;
else
segment->m_type = ENUM_MODULE_TEXT;
segment->m_module_name = (char*) core_to_mmap_addr((address_t)GetUInt(&linkmap->l_name));
#ifdef linux
if (segment->m_module_name == NULL)
{
if (linkmap == gLinkMap_32)
segment->m_module_name = gpInputExecName;
else
segment->m_module_name = "/lib/ld-linux-x86-64.so.2";
}
#endif
}
}
}
if ((address_t)GetUInt(&linkmap->l_next) == 0)
break;
linkmap = (struct link_map_32*) core_to_mmap_addr((address_t)GetULong(&linkmap->l_next));
if (linkmap == gLinkMap_32)
break;
}
#ifdef CA_DEBUG
linkmap = gLinkMap_32;
for (int i=0; linkmap; i++)
{
char* name = (char*) core_to_mmap_addr((address_t)GetUInt(&linkmap->l_name));
// find the strtab
void* strtab = NULL;
dyn = (Elf32_Dyn*) core_to_mmap_addr((address_t)GetUInt(&linkmap->l_ld));
while (dyn && GetUInt(&dyn->d_tag))
{
if (GetUInt(&dyn->d_tag) == DT_STRTAB)
strtab = (void*)GetUInt(&dyn->d_un.d_ptr);
dyn++;
};
printf("[%d] base=[0x%lx] name=%s .dyn=0x%lx\n", i, GetUInt(&linkmap->l_addr), name, GetUInt(&linkmap->l_ld));
if (linkmap->l_next == 0)
break;
linkmap = (struct link_map_32*) core_to_mmap_addr((address_t)GetUInt(&linkmap->l_next));
if (linkmap == gLinkMap_32)
break;
}
#endif
return true;
}
bool CIEC104DeliverQuery::IsStartFrame()
{
if (GetUInt(2,1) == 0x07)
return true;
return false;
}
WORD CIEC104DeliverQuery::GetSendFrameNo()
{
Q_ASSERT(GetFrameType() == IEC104_I_TYPE );
WORD nSendFrameNo = GetUInt(2,2);
return nSendFrameNo >>1;
}
WORD CIEC104DeliverQuery::GetReceiveFrameNo()
{
Q_ASSERT(GetFrameType() != IEC104_U_TYPE );
WORD nReceiveFrameNo = GetUInt(4,2);
return nReceiveFrameNo>>1;
}
bool CIEC104DeliverQuery::Is104Frame()
{
if (GetUInt(0,1) == 0x68)
return true;
return false;
}
bool CIEC104DeliverQuery::IsTestFrame()
{
if (GetUInt(2,1) == 0x43)
return true;
return false;
}
// Creates a Value* of unsigned integer8 type from the value passed.
Value *GetUInt8(CodeGenerator *codegen, demi_int val) {
return GetUInt(codegen, val, 8);
}
/*!
* \brief 功能概述 是否为测试帧
* \param 参数描述 无
* \return 返回值描述 如果为测试帧则返回true，否则返回false
* \author zzy
* \date 2015/5/25
*/
bool CIEC104Response::IsTestFrame()
{
Q_ASSERT(GetFrameType() == IEC104_U_TYPE );
BYTE nControlByte1 = GetUInt(2,1);
return (nControlByte1&0x80)!=0;
}
/*!
* \brief 功能概述 获取发送序号
* \param 参数描述 无
* \return 返回值描述 返回报文中的发送序号
* \author zzy
* \date 2015/5/25
*/
WORD CIEC104Response::GetSendFrameNo()
{
Q_ASSERT(GetFrameType() == IEC104_I_TYPE );
WORD nSendFrameNo = GetUInt(2,2);
return nSendFrameNo >>1;
}
template <> unsigned Variant::Get<unsigned>() const
{
return GetUInt();
}
// Creates a Value* of the demiurge unsigned integer size.
// This should be used for any generic number type such as constants
Value *GetDemiUInt(CodeGenerator *codegen, demi_int val) {
return GetUInt(codegen, val, 32);
}
