IDA Pro反编译代码类型转换参考

 /*

    This file contains definitions used by the Hex-Rays decompiler output.
    It has type definitions and convenience macros to make the
    output more readable.

    Copyright (c) 2007-2011 Hex-Rays

 */

 #if defined(__GNUC__)
   typedef          long long ll;
   typedef unsigned long long ull;
   #define __int64 long long
   #define __int32 int
   #define __int16 short
   #define __int8  char
   #define MAKELL(num) num ## LL
   #define FMT_64 "ll"
 #elif defined(_MSC_VER)
   typedef          __int64 ll;
   typedef unsigned __int64 ull;
   #define MAKELL(num) num ## i64
   #define FMT_64 "I64"
 #elif defined (__BORLANDC__)
   typedef          __int64 ll;
   typedef unsigned __int64 ull;
   #define MAKELL(num) num ## i64
   #define FMT_64 "L"
 #else
   #error "unknown compiler"
 #endif
 typedef unsigned int uint;
 typedef unsigned char uchar;
 typedef unsigned short ushort;
 typedef unsigned long ulong;

 typedef          char   int8;
 typedef   signed char   sint8;
 typedef unsigned char   uint8;
 typedef          short  int16;
 typedef   signed short  sint16;
 typedef unsigned short  uint16;
 typedef          int    int32;
 typedef   signed int    sint32;
 typedef unsigned int    uint32;
 typedef ll              int64;
 typedef ll              sint64;
 typedef ull             uint64;

 // Partially defined types:
 #define _BYTE  uint8
 #define _WORD  uint16
 #define _DWORD uint32
 #define _QWORD uint64
 #if !defined(_MSC_VER)
 #define _LONGLONG __int128
 #endif

 #ifndef _WINDOWS_
 typedef int8 BYTE;
 typedef int16 WORD;
 typedef int32 DWORD;
 typedef int32 LONG;
 #endif
 typedef int64 QWORD;
 #ifndef __cplusplus
 typedef int bool;       // we want to use bool in our C programs
 #endif

 // Some convenience macros to make partial accesses nicer
 // first unsigned macros:
 #define LOBYTE(x)   (*((_BYTE*)&(x)))   // low byte
 #define LOWORD(x)   (*((_WORD*)&(x)))   // low word
 #define LODWORD(x)  (*((_DWORD*)&(x)))  // low dword
 #define HIBYTE(x)   (*((_BYTE*)&(x)+1))
 #define HIWORD(x)   (*((_WORD*)&(x)+1))
 #define HIDWORD(x)  (*((_DWORD*)&(x)+1))
 #define BYTEn(x, n)   (*((_BYTE*)&(x)+n))
 #define WORDn(x, n)   (*((_WORD*)&(x)+n))
 #define BYTE1(x)   BYTEn(x,  1)         // byte 1 (counting from 0)
 #define BYTE2(x)   BYTEn(x,  2)
 #define BYTE3(x)   BYTEn(x,  3)
 #define BYTE4(x)   BYTEn(x,  4)
 #define BYTE5(x)   BYTEn(x,  5)
 #define BYTE6(x)   BYTEn(x,  6)
 #define BYTE7(x)   BYTEn(x,  7)
 #define BYTE8(x)   BYTEn(x,  8)
 #define BYTE9(x)   BYTEn(x,  9)
 #define BYTE10(x)  BYTEn(x, 10)
 #define BYTE11(x)  BYTEn(x, 11)
 #define BYTE12(x)  BYTEn(x, 12)
 #define BYTE13(x)  BYTEn(x, 13)
 #define BYTE14(x)  BYTEn(x, 14)
 #define BYTE15(x)  BYTEn(x, 15)
 #define WORD1(x)   WORDn(x,  1)
 #define WORD2(x)   WORDn(x,  2)         // third word of the object, unsigned
 #define WORD3(x)   WORDn(x,  3)
 #define WORD4(x)   WORDn(x,  4)
 #define WORD5(x)   WORDn(x,  5)
 #define WORD6(x)   WORDn(x,  6)
 #define WORD7(x)   WORDn(x,  7)

 // now signed macros (the same but with sign extension)
 #define SLOBYTE(x)   (*((int8*)&(x)))
 #define SLOWORD(x)   (*((int16*)&(x)))
 #define SLODWORD(x)  (*((int32*)&(x)))
 #define SHIBYTE(x)   (*((int8*)&(x)+1))
 #define SHIWORD(x)   (*((int16*)&(x)+1))
 #define SHIDWORD(x)  (*((int32*)&(x)+1))
 #define SBYTEn(x, n)   (*((int8*)&(x)+n))
 #define SWORDn(x, n)   (*((int16*)&(x)+n))
 #define SBYTE1(x)   SBYTEn(x,  1)
 #define SBYTE2(x)   SBYTEn(x,  2)
 #define SBYTE3(x)   SBYTEn(x,  3)
 #define SBYTE4(x)   SBYTEn(x,  4)
 #define SBYTE5(x)   SBYTEn(x,  5)
 #define SBYTE6(x)   SBYTEn(x,  6)
 #define SBYTE7(x)   SBYTEn(x,  7)
 #define SBYTE8(x)   SBYTEn(x,  8)
 #define SBYTE9(x)   SBYTEn(x,  9)
 #define SBYTE10(x)  SBYTEn(x, 10)
 #define SBYTE11(x)  SBYTEn(x, 11)
 #define SBYTE12(x)  SBYTEn(x, 12)
 #define SBYTE13(x)  SBYTEn(x, 13)
 #define SBYTE14(x)  SBYTEn(x, 14)
 #define SBYTE15(x)  SBYTEn(x, 15)
 #define SWORD1(x)   SWORDn(x,  1)
 #define SWORD2(x)   SWORDn(x,  2)
 #define SWORD3(x)   SWORDn(x,  3)
 #define SWORD4(x)   SWORDn(x,  4)
 #define SWORD5(x)   SWORDn(x,  5)
 #define SWORD6(x)   SWORDn(x,  6)
 #define SWORD7(x)   SWORDn(x,  7)

 // Helper functions to represent some assembly instructions.

 #ifdef __cplusplus

 // Fill memory block with an integer value
 inline void memset32(void *ptr, uint32 value, int count)
 {
   uint32 *p = (uint32 *)ptr;
   for ( int i=; i < count; i++ )
     *p++ = value;
 }

 // Generate a reference to pair of operands
 template<class T>  int16 __PAIR__( int8  high, T low) { return ((( int16)high) << sizeof(high)*) | uint8(low); }
 template<class T>  int32 __PAIR__( int16 high, T low) { return ((( int32)high) << sizeof(high)*) | uint16(low); }
 template<class T>  int64 __PAIR__( int32 high, T low) { return ((( int64)high) << sizeof(high)*) | uint32(low); }
 template<class T> uint16 __PAIR__(uint8  high, T low) { return (((uint16)high) << sizeof(high)*) | uint8(low); }
 template<class T> uint32 __PAIR__(uint16 high, T low) { return (((uint32)high) << sizeof(high)*) | uint16(low); }
 template<class T> uint64 __PAIR__(uint32 high, T low) { return (((uint64)high) << sizeof(high)*) | uint32(low); }

 // rotate left
 template<class T> T __ROL__(T value, uint count)
 {
   const uint nbits = sizeof(T) * ;
   count %= nbits;

   T high = value >> (nbits - count);
   value <<= count;
   value |= high;
   return value;
 }

 // rotate right
 template<class T> T __ROR__(T value, uint count)
 {
   const uint nbits = sizeof(T) * ;
   count %= nbits;

   T low = value << (nbits - count);
   value >>= count;
   value |= low;
   return value;
 }

 // carry flag of left shift
 template<class T> int8 __MKCSHL__(T value, uint count)
 {
   const uint nbits = sizeof(T) * ;
   count %= nbits;

   return (value >> (nbits-count)) & ;
 }

 // carry flag of right shift
 template<class T> int8 __MKCSHR__(T value, uint count)
 {
   return (value >> (count-)) & ;
 }

 // sign flag
 template<class T> int8 __SETS__(T x)
 {
   if ( sizeof(T) ==  )
     return int8(x) < ;
   if ( sizeof(T) ==  )
     return int16(x) < ;
   if ( sizeof(T) ==  )
     return int32(x) < ;
   return int64(x) < ;
 }

 // overflow flag of subtraction (x-y)
 template<class T, class U> int8 __OFSUB__(T x, U y)
 {
   if ( sizeof(T) < sizeof(U) )
   {
     U x2 = x;
     int8 sx = __SETS__(x2);
     return (sx ^ __SETS__(y)) & (sx ^ __SETS__(x2-y));
   }
   else
   {
     T y2 = y;
     int8 sx = __SETS__(x);
     return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2));
   }
 }

 // overflow flag of addition (x+y)
 template<class T, class U> int8 __OFADD__(T x, U y)
 {
   if ( sizeof(T) < sizeof(U) )
   {
     U x2 = x;
     int8 sx = __SETS__(x2);
     return (( ^ sx) ^ __SETS__(y)) & (sx ^ __SETS__(x2+y));
   }
   else
   {
     T y2 = y;
     int8 sx = __SETS__(x);
     return (( ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(x+y2));
   }
 }

 // carry flag of subtraction (x-y)
 template<class T, class U> int8 __CFSUB__(T x, U y)
 {
   int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);
   if ( size ==  )
     return uint8(x) < uint8(y);
   if ( size ==  )
     return uint16(x) < uint16(y);
   if ( size ==  )
     return uint32(x) < uint32(y);
   return uint64(x) < uint64(y);
 }

 // carry flag of addition (x+y)
 template<class T, class U> int8 __CFADD__(T x, U y)
 {
   int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);
   if ( size ==  )
     return uint8(x) > uint8(x+y);
   if ( size ==  )
     return uint16(x) > uint16(x+y);
   if ( size ==  )
     return uint32(x) > uint32(x+y);
   return uint64(x) > uint64(x+y);
 }

 #else
 // The following definition is not quite correct because it always returns
 // uint64. The above C++ functions are good, though.
 #define __PAIR__(high, low) (((uint64)(high)<<sizeof(high)*8) | low)
 // For C, we just provide macros, they are not quite correct.
 #define __ROL__(x, y) __rotl__(x, y)      // Rotate left
 #define __ROR__(x, y) __rotr__(x, y)      // Rotate right
 #define __CFSHL__(x, y) invalid_operation // Generate carry flag for (x<<y)
 #define __CFSHR__(x, y) invalid_operation // Generate carry flag for (x>>y)
 #define __CFADD__(x, y) invalid_operation // Generate carry flag for (x+y)
 #define __CFSUB__(x, y) invalid_operation // Generate carry flag for (x-y)
 #define __OFADD__(x, y) invalid_operation // Generate overflow flag for (x+y)
 #define __OFSUB__(x, y) invalid_operation // Generate overflow flag for (x-y)
 #endif

 // No definition for rcl/rcr because the carry flag is unknown
 #define __RCL__(x, y)    invalid_operation // Rotate left thru carry
 #define __RCR__(x, y)    invalid_operation // Rotate right thru carry
 #define __MKCRCL__(x, y) invalid_operation // Generate carry flag for a RCL
 #define __MKCRCR__(x, y) invalid_operation // Generate carry flag for a RCR
 #define __SETP__(x, y)   invalid_operation // Generate parity flag for (x-y)

 // In the decompilation listing there are some objects declarared as _UNKNOWN
 // because we could not determine their types. Since the C compiler does not
 // accept void item declarations, we replace them by anything of our choice,
 // for example a char:

 #define _UNKNOWN char

 #ifdef _MSC_VER
 #define snprintf _snprintf
 #define vsnprintf _vsnprintf
 #endif