std::string IDASigOSToString(uint32_t flags)
{
std::string ret;
FLAG_STRING(IDASIG__OS__MSDOS, "MSDOS");
FLAG_STRING(IDASIG__OS__WIN, "WIN");
FLAG_STRING(IDASIG__OS__OS2, "OS2");
FLAG_STRING(IDASIG__OS__NETWARE, "NETWARE");
FLAG_STRING(IDASIG__OS__UNIX, "UNIX");
return ret;
}
std::string IDASigFeaturesToString(uint32_t flags)
{
std::string ret;
FLAG_STRING(IDASIG__FEATURE__STARTUP, "STARTUP");
FLAG_STRING(IDASIG__FEATURE__CTYPE_CRC, "CTYPE_CRC");
FLAG_STRING(IDASIG__FEATURE__2BYTE_CTYPE, "2BYTE_CTYPE");
FLAG_STRING(IDASIG__FEATURE__ALT_CTYPE_CRC, "ALT_CTYPE_CRC");
FLAG_STRING(IDASIG__FEATURE__COMPRESSED, "COMPRESSED");
return ret;
}
std::string
_nasm_interface::format_usage(
__in_opt bool verbose
)
{
size_t iter = 0;
std::stringstream result;
TRACE_ENTRY();
if(verbose) {
result << format_version(false, true, true) << std::endl << std::endl;
}
result << USAGE_STRING;
if(verbose) {
result << std::endl;
for(; iter <= MAX_FLAG; ++iter) {
result << std::endl << FLAG_PREFIX << FLAG_STRING(iter) << " "
<< FLAG_PREFIX << FLAG_PREFIX << FLAG_LONG_STRING(iter)
<< std::left << std::setw(USAGE_COLUMN_WIDTH - FLAG_LONG_STRING(iter).size())
<< " " << FLAG_CAPTION_STRING(iter);
}
}
TRACE_EXIT("Return Value: 0x%x", NULL);
return result.str();
}
std::string IDASigApplicationToString(uint32_t flags)
{
std::string ret;
FLAG_STRING(IDASIG__APP__CONSOLE, "CONSOLE");
FLAG_STRING(IDASIG__APP__GRAPHICS, "GRAPHICS");
FLAG_STRING(IDASIG__APP__EXE, "EXE");
FLAG_STRING(IDASIG__APP__DLL, "DLL");
FLAG_STRING(IDASIG__APP__DRV, "DRV");
FLAG_STRING(IDASIG__APP__SINGLE_THREADED, "SINGLE_THREADED");
FLAG_STRING(IDASIG__APP__MULTI_THREADED, "MULTI_THREADED");
FLAG_STRING(IDASIG__APP__16_BIT, "16_BIT");
FLAG_STRING(IDASIG__APP__32_BIT, "32_BIT");
FLAG_STRING(IDASIG__APP__64_BIT, "64_BIT");
return ret;
}
// Returns a "human readable" string representation of the MSG and the
// information it points to
QString decodeMSG(const MSG& msg)
{
const WPARAM wParam = msg.wParam;
const LPARAM lParam = msg.lParam;
QString wmmsg = QString::fromLatin1(findWMstr(msg.message));
// Unknown WM_, so use number
if (wmmsg.isEmpty())
wmmsg = QString::fromLatin1("WM_(%1)").arg(msg.message);
QString rawParameters;
rawParameters.sprintf("hwnd(0x%p) ", (void *)msg.hwnd);
// Custom WM_'s
if (msg.message > WM_APP)
wmmsg = QString::fromLatin1("WM_APP + %1").arg(msg.message - WM_APP);
else if (msg.message > WM_USER)
wmmsg = QString::fromLatin1("WM_USER + %1").arg(msg.message - WM_USER);
QString parameters;
switch (msg.message) {
#ifdef WM_ACTIVATE
case WM_ACTIVATE:
{
QString activation = valueCheck(wParam,
FLAG_STRING(WA_ACTIVE, "Activate"),
FLAG_STRING(WA_INACTIVE, "Deactivate"),
FLAG_STRING(WA_CLICKACTIVE, "Activate by mouseclick"),
FLAG_STRING());
parameters.sprintf("%s Hwnd (0x%p)", activation.toLatin1().data(), (void *)msg.hwnd);
}
break;
#endif
#ifdef WM_CAPTURECHANGED
case WM_CAPTURECHANGED:
parameters.sprintf("Hwnd gaining capture (0x%p)", (void *)lParam);
break;
#endif
#ifdef WM_CREATE
case WM_CREATE:
{
LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
QString styles = flagCheck(lpcs->style,
FLGSTR(WS_BORDER),
FLGSTR(WS_CAPTION),
FLGSTR(WS_CHILD),
FLGSTR(WS_CLIPCHILDREN),
FLGSTR(WS_CLIPSIBLINGS),
FLGSTR(WS_DISABLED),
FLGSTR(WS_DLGFRAME),
FLGSTR(WS_GROUP),
FLGSTR(WS_HSCROLL),
FLGSTR(WS_OVERLAPPED),
#if defined(WS_OVERLAPPEDWINDOW) && (WS_OVERLAPPEDWINDOW != 0)
FLGSTR(WS_OVERLAPPEDWINDOW),
#endif
#ifdef WS_ICONIC
FLGSTR(WS_ICONIC),
#endif
FLGSTR(WS_MAXIMIZE),
FLGSTR(WS_MAXIMIZEBOX),
FLGSTR(WS_MINIMIZE),
FLGSTR(WS_MINIMIZEBOX),
FLGSTR(WS_OVERLAPPEDWINDOW),
FLGSTR(WS_POPUP),
#ifdef WS_POPUPWINDOW
FLGSTR(WS_POPUPWINDOW),
#endif
FLGSTR(WS_SIZEBOX),
FLGSTR(WS_SYSMENU),
FLGSTR(WS_TABSTOP),
FLGSTR(WS_THICKFRAME),
#ifdef WS_TILED
FLGSTR(WS_TILED),
#endif
#ifdef WS_TILEDWINDOW
FLGSTR(WS_TILEDWINDOW),
#endif
FLGSTR(WS_VISIBLE),
FLGSTR(WS_VSCROLL),
FLAG_STRING());
QString exStyles = flagCheck(lpcs->dwExStyle,
#ifdef WS_EX_ACCEPTFILES
FLGSTR(WS_EX_ACCEPTFILES),
#endif
#ifdef WS_EX_APPWINDOW
FLGSTR(WS_EX_APPWINDOW),
#endif
FLGSTR(WS_EX_CLIENTEDGE),
FLGSTR(WS_EX_DLGMODALFRAME),
#ifdef WS_EX_LEFT
FLGSTR(WS_EX_LEFT),
#endif
FLGSTR(WS_EX_LEFTSCROLLBAR),
#ifdef WS_EX_LTRREADING
FLGSTR(WS_EX_LTRREADING),
#endif
#ifdef WS_EX_MDICHILD
FLGSTR(WS_EX_MDICHILD),
#endif
#ifdef WS_EX_NOACTIVATE
FLGSTR(WS_EX_NOACTIVATE),
#endif
#ifdef WS_EX_NOANIMATION
FLGSTR(WS_EX_NOANIMATION),
#endif
FLGSTR(WS_EX_NOPARENTNOTIFY),
FLGSTR(WS_EX_OVERLAPPEDWINDOW),
#ifdef WS_EX_PALETTEWINDOW
FLGSTR(WS_EX_PALETTEWINDOW),
#endif
#ifdef WS_EX_RIGHT
FLGSTR(WS_EX_RIGHT),
#endif
#ifdef WS_EX_RIGHTSCROLLBAR
FLGSTR(WS_EX_RIGHTSCROLLBAR),
#endif
#ifdef WS_EX_RTLREADING
FLGSTR(WS_EX_RTLREADING),
#endif
FLGSTR(WS_EX_STATICEDGE),
FLGSTR(WS_EX_TOOLWINDOW),
FLGSTR(WS_EX_TOPMOST),
#ifdef WS_EX_TRANSPARENT
FLGSTR(WS_EX_TRANSPARENT),
#endif
FLGSTR(WS_EX_WINDOWEDGE),
#ifdef WS_EX_CAPTIONOKBTN
FLGSTR(WS_EX_CAPTIONOKBTN),
#endif
FLAG_STRING());
QString className;
if (lpcs->lpszClass != 0) {
if (HIWORD(lpcs->lpszClass) == 0) // Atom
className = QString::number(LOWORD(lpcs->lpszClass), 16);
else // String
className = QString((QChar*)lpcs->lpszClass,
(int)wcslen(reinterpret_cast<const wchar_t *>(lpcs->lpszClass)));
}
QString windowName;
if (lpcs->lpszName != 0)
windowName = QString((QChar*)lpcs->lpszName,
(int)wcslen(reinterpret_cast<const wchar_t *>(lpcs->lpszName)));
parameters.sprintf("x,y(%4d,%4d) w,h(%4d,%4d) className(%s) windowName(%s) parent(0x%p) style(%s) exStyle(%s)",
lpcs->x, lpcs->y, lpcs->cx, lpcs->cy, className.toLatin1().data(),
windowName.toLatin1().data(), (void *)lpcs->hwndParent,
styles.toLatin1().data(), exStyles.toLatin1().data());
}
break;
#endif
#ifdef WM_DESTROY
case WM_DESTROY:
parameters.sprintf("Destroy hwnd (0x%p)", (void *)msg.hwnd);
break;
#endif
#ifdef WM_IME_NOTIFY
case WM_IME_NOTIFY:
{
QString imnCommand = valueCheck(wParam,
FLGSTR(IMN_CHANGECANDIDATE),
FLGSTR(IMN_CLOSECANDIDATE),
FLGSTR(IMN_CLOSESTATUSWINDOW),
FLGSTR(IMN_GUIDELINE),
FLGSTR(IMN_OPENCANDIDATE),
FLGSTR(IMN_OPENSTATUSWINDOW),
FLGSTR(IMN_SETCANDIDATEPOS),
FLGSTR(IMN_SETCOMPOSITIONFONT),
FLGSTR(IMN_SETCOMPOSITIONWINDOW),
FLGSTR(IMN_SETCONVERSIONMODE),
FLGSTR(IMN_SETOPENSTATUS),
FLGSTR(IMN_SETSENTENCEMODE),
FLGSTR(IMN_SETSTATUSWINDOWPOS),
FLAG_STRING());
parameters.sprintf("Command(%s : 0x%p)", imnCommand.toLatin1().data(), (void *)lParam);
}
break;
#endif
#ifdef WM_IME_SETCONTEXT
case WM_IME_SETCONTEXT:
{
bool fSet = (BOOL)wParam;
DWORD fShow = (DWORD)lParam;
QString showFlgs = flagCheck(fShow,
#ifdef ISC_SHOWUICOMPOSITIONWINDOW
FLGSTR(ISC_SHOWUICOMPOSITIONWINDOW),
#endif
#ifdef ISC_SHOWUIGUIDWINDOW
FLGSTR(ISC_SHOWUIGUIDWINDOW),
#endif
#ifdef ISC_SHOWUISOFTKBD
FLGSTR(ISC_SHOWUISOFTKBD),
#endif
FLGSTR(ISC_SHOWUICANDIDATEWINDOW),
FLGSTR(ISC_SHOWUICANDIDATEWINDOW << 1),
FLGSTR(ISC_SHOWUICANDIDATEWINDOW << 2),
FLGSTR(ISC_SHOWUICANDIDATEWINDOW << 3),
FLAG_STRING());
parameters.sprintf("Input context(%s) Show flags(%s)", (fSet? "Active" : "Inactive"), showFlgs.toLatin1().data());
}
break;
#endif
#ifdef WM_KILLFOCUS
case WM_KILLFOCUS:
parameters.sprintf("Hwnd gaining keyboard focus (0x%p)", (void *)wParam);
break;
#endif
#ifdef WM_CHAR
case WM_CHAR:
#endif
#ifdef WM_IME_CHAR
case WM_IME_CHAR:
#endif
#ifdef WM_KEYDOWN
case WM_KEYDOWN:
#endif
#ifdef WM_KEYUP
case WM_KEYUP:
{
int nVirtKey = (int)wParam;
long lKeyData = (long)lParam;
int repCount = (lKeyData & 0xffff); // Bit 0-15
int scanCode = (lKeyData & 0xf0000) >> 16; // Bit 16-23
bool contextCode = (lKeyData && 0x20000000); // Bit 29
bool prevState = (lKeyData && 0x40000000); // Bit 30
bool transState = (lKeyData && 0x80000000); // Bit 31
parameters.sprintf("Virual-key(0x%x) Scancode(%d) Rep(%d) Contextcode(%d), Prev state(%d), Trans state(%d)",
nVirtKey, scanCode, repCount, contextCode, prevState, transState);
}
break;
#endif
#ifdef WM_INPUTLANGCHANGE
case WM_INPUTLANGCHANGE:
parameters = QLatin1String("Keyboard layout changed");
break;
#endif // WM_INPUTLANGCHANGE
#ifdef WM_NCACTIVATE
case WM_NCACTIVATE:
{
parameters = (msg.wParam? QLatin1String("Active Titlebar") : QLatin1String("Inactive Titlebar"));
}
break;
#endif
#ifdef WM_MOUSEACTIVATE
case WM_MOUSEACTIVATE:
{
QString mouseMsg = QString::fromLatin1(findWMstr(HIWORD(lParam)));
parameters.sprintf("TLW(0x%p) HittestCode(0x%x) MouseMsg(%s)", (void *)wParam, LOWORD(lParam), mouseMsg.toLatin1().data());
}
break;
#endif
#ifdef WM_MOUSELEAVE
case WM_MOUSELEAVE:
break; // wParam & lParam not used
#endif
#ifdef WM_MOUSEHOVER
case WM_MOUSEHOVER:
#endif
#ifdef WM_MOUSEWHEEL
case WM_MOUSEWHEEL:
#endif
#ifdef WM_MOUSEHWHEEL
case WM_MOUSEHWHEEL:
#endif
#ifdef WM_LBUTTONDBLCLK
case WM_LBUTTONDBLCLK:
#endif
#ifdef WM_LBUTTONDOWN
case WM_LBUTTONDOWN:
#endif
#ifdef WM_LBUTTONUP
case WM_LBUTTONUP:
#endif
#ifdef WM_MBUTTONDBLCLK
case WM_MBUTTONDBLCLK:
#endif
#ifdef WM_MBUTTONDOWN
case WM_MBUTTONDOWN:
#endif
#ifdef WM_MBUTTONUP
case WM_MBUTTONUP:
#endif
#ifdef WM_RBUTTONDBLCLK
case WM_RBUTTONDBLCLK:
#endif
#ifdef WM_RBUTTONDOWN
case WM_RBUTTONDOWN:
#endif
#ifdef WM_RBUTTONUP
case WM_RBUTTONUP:
#endif
#ifdef WM_MOUSEMOVE
case WM_MOUSEMOVE:
{
QString vrtKeys = flagCheck(wParam,
FLGSTR(MK_CONTROL),
FLGSTR(MK_LBUTTON),
FLGSTR(MK_MBUTTON),
FLGSTR(MK_RBUTTON),
FLGSTR(MK_SHIFT),
#ifdef MK_XBUTTON1
FLGSTR(MK_XBUTTON1),
#endif
#ifdef MK_XBUTTON2
FLGSTR(MK_XBUTTON2),
#endif
FLAG_STRING());
parameters.sprintf("x,y(%4d,%4d) Virtual Keys(%s)", GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), vrtKeys.toLatin1().data());
}
break;
#endif
#ifdef WM_MOVE
case WM_MOVE:
parameters.sprintf("x,y(%4d,%4d)", LOWORD(lParam), HIWORD(lParam));
break;
#endif
#if defined(WM_PAINT) && defined(WM_ERASEBKGND)
case WM_ERASEBKGND:
case WM_PAINT:
parameters.sprintf("hdc(0x%p)", (void *)wParam);
break;
#endif
#ifdef WM_QUERYNEWPALETTE
case WM_QUERYNEWPALETTE:
break; // lParam & wParam are unused
#endif
#ifdef WM_SETCURSOR
case WM_SETCURSOR:
{
QString mouseMsg = QString::fromLatin1(findWMstr(HIWORD(lParam)));
parameters.sprintf("HitTestCode(0x%x) MouseMsg(%s)", LOWORD(lParam), mouseMsg.toLatin1().data());
}
break;
#endif
#ifdef WM_SETFOCUS
case WM_SETFOCUS:
parameters.sprintf("Lost Focus (0x%p)", (void *)wParam);
break;
#endif
#ifdef WM_SETTEXT
case WM_SETTEXT:
parameters.sprintf("Set Text (%s)", QString((QChar*)lParam, (int)wcslen(reinterpret_cast<const wchar_t *>(lParam))).toLatin1().data()); //Unicode string
break;
#endif
#ifdef WM_SIZE
case WM_SIZE:
{
QString showMode = valueCheck(wParam,
FLGSTR(SIZE_MAXHIDE),
FLGSTR(SIZE_MAXIMIZED),
FLGSTR(SIZE_MAXSHOW),
FLGSTR(SIZE_MINIMIZED),
FLGSTR(SIZE_RESTORED),
FLAG_STRING());
parameters.sprintf("w,h(%4d,%4d) showmode(%s)", LOWORD(lParam), HIWORD(lParam), showMode.toLatin1().data());
}
break;
#endif
#ifdef WM_WINDOWPOSCHANGED
case WM_WINDOWPOSCHANGED:
{
LPWINDOWPOS winPos = (LPWINDOWPOS)lParam;
if (!winPos)
break;
QString hwndAfter = valueCheck(quint64(winPos->hwndInsertAfter),
FLAG_STRING((qptrdiff)HWND_BOTTOM, "HWND_BOTTOM"),
FLAG_STRING((qptrdiff)HWND_NOTOPMOST, "HWND_NOTOPMOST"),
FLAG_STRING((qptrdiff)HWND_TOP, "HWND_TOP"),
FLAG_STRING((qptrdiff)HWND_TOPMOST, "HWND_TOPMOST"),
FLAG_STRING());
if (hwndAfter.isEmpty())
hwndAfter = QString::number((quintptr)winPos->hwndInsertAfter, 16);
QString flags = flagCheck(winPos->flags,
FLGSTR(SWP_DRAWFRAME),
FLGSTR(SWP_FRAMECHANGED),
FLGSTR(SWP_HIDEWINDOW),
FLGSTR(SWP_NOACTIVATE),
#ifdef SWP_NOCOPYBITS
FLGSTR(SWP_NOCOPYBITS),
#endif
FLGSTR(SWP_NOMOVE),
FLGSTR(SWP_NOOWNERZORDER),
FLGSTR(SWP_NOREDRAW),
FLGSTR(SWP_NOREPOSITION),
#ifdef SWP_NOSENDCHANGING
FLGSTR(SWP_NOSENDCHANGING),
#endif
FLGSTR(SWP_NOSIZE),
FLGSTR(SWP_NOZORDER),
FLGSTR(SWP_SHOWWINDOW),
FLAG_STRING());
parameters.sprintf("x,y(%4d,%4d) w,h(%4d,%4d) flags(%s) hwndAfter(%s)", winPos->x, winPos->y, winPos->cx, winPos->cy, flags.toLatin1().data(), hwndAfter.toLatin1().data());
}
break;
#endif
default:
parameters.sprintf("wParam(0x%p) lParam(0x%p)", (void *)wParam, (void *)lParam);
break;
}
// Yes, we want to give the WM_ names 20 chars of space before showing the
// decoded message, since some of the common messages are quite long, and
// we don't want the decoded information to vary in output position
QString message = QString::fromLatin1("%1: ").arg(wmmsg, 20);
message += rawParameters;
message += parameters;
return message;
}
std::string IDASigFileToString(uint32_t flags)
{
std::string ret;
FLAG_STRING(IDASIG__FILE__DOS_EXE_OLD, "DOS_EXE_OLD");
FLAG_STRING(IDASIG__FILE__DOS_COM_OLD, "DOS_COM_OLD");
FLAG_STRING(IDASIG__FILE__BIN, "BIN");
FLAG_STRING(IDASIG__FILE__DOSDRV, "DOSDRV");
FLAG_STRING(IDASIG__FILE__NE, "NE");
FLAG_STRING(IDASIG__FILE__INTELHEX, "INTELHEX");
FLAG_STRING(IDASIG__FILE__MOSHEX, "MOSHEX");
FLAG_STRING(IDASIG__FILE__LX, "LX");
FLAG_STRING(IDASIG__FILE__LE, "LE");
FLAG_STRING(IDASIG__FILE__NLM, "NLM");
FLAG_STRING(IDASIG__FILE__COFF, "COFF");
FLAG_STRING(IDASIG__FILE__PE, "PE");
FLAG_STRING(IDASIG__FILE__OMF, "OMF");
FLAG_STRING(IDASIG__FILE__SREC, "SREC");
FLAG_STRING(IDASIG__FILE__ZIP, "ZIP");
FLAG_STRING(IDASIG__FILE__OMFLIB, "OMFLIB");
FLAG_STRING(IDASIG__FILE__AR, "AR");
FLAG_STRING(IDASIG__FILE__LOADER, "LOADER");
FLAG_STRING(IDASIG__FILE__ELF, "ELF");
FLAG_STRING(IDASIG__FILE__W32RUN, "W32RUN");
FLAG_STRING(IDASIG__FILE__AOUT, "AOUT");
FLAG_STRING(IDASIG__FILE__PILOT, "PILOT");
FLAG_STRING(IDASIG__FILE__DOS_EXE, "EXE");
FLAG_STRING(IDASIG__FILE__AIXAR, "AIXAR");
return ret;
}
void
_nasm_interface::parse_arguments(void)
{
std::string arg_str;
size_t arg_count = 0, flag_iter;
nasm_arguments::iterator arg_iter;
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
for(arg_iter = m_arguments.begin(); arg_iter != m_arguments.end(); ++arg_iter, ++arg_count) {
if(arg_iter->empty()) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_UNEXPECTED_EMPTY_ARGUMENT,
"%lu", arg_count);
}
arg_str = *arg_iter;
if(arg_str.at(0) == FLAG_PREFIX) {
arg_str.erase(arg_str.begin());
if(arg_str.empty()) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_INVALID_FLAG,
"%s", (*arg_iter).c_str());
}
if(arg_str.at(0) == FLAG_PREFIX) {
arg_str.erase(arg_str.begin());
if(arg_str.empty()) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_INVALID_FLAG,
"%s", (*arg_iter).c_str());
}
TRANSFORM(tolower, arg_str);
for(flag_iter = 0; flag_iter <= MAX_FLAG; ++flag_iter) {
if(arg_str == FLAG_LONG_STRING(flag_iter)) {
break;
}
}
} else {
TRANSFORM(tolower, arg_str);
for(flag_iter = 0; flag_iter <= MAX_FLAG; ++flag_iter) {
if(arg_str == FLAG_STRING(flag_iter)) {
break;
}
}
if(flag_iter > MAX_FLAG) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_UNKNOWN_FLAG,
"%s", (*arg_iter).c_str());
}
}
process_argument(arg_iter, flag_iter);
} else {
if(!m_input_path.empty()) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_INPUT_PATH_REDEFINITION,
"%s", (*arg_iter).c_str());
}
m_input_path = arg_str;
}
}
if(m_output_path.empty()
&& !m_input_path.empty()
&& !determine_base_path(m_output_path, m_input_path)) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_BASE_PATH_FAILURE,
"%s", m_input_path.c_str());
}
TRACE_EXIT("Return Value: 0x%x", NULL);
}
CMyString& operator << (CMyString& str, EIppFlag val) {
str += FLAG_STRING(Flag,val);
return str;
}
