test.c

汇编语言编的TOOLHELPasm.rar程序,初学者可能会用到哦^_^TOOLHELPasm.rar

        case IDM_TEST_11:
            if (wListStatus != LIST_TASK)
                return 0L;

            /* Get the task handle from the list box */
            SendMessage(hwndList, LB_GETTEXT,
                (WORD)SendMessage(hwndList, LB_GETCURSEL, 0, 0L),
                (LONG)(LPSTR)szText);
            sscanf(szText, "%*6c%x", &hTask);

            /* Nuke the task if it is not the current one */
            if (hTask != wsProgramTask)
                TerminateApp(hTask, NO_UAE_BOX);

            /* Update the task list and get out */
            return WalkTaskList(hwnd);

        case IDM_TEST_12:
            return TimerCountTest(hwnd);

        case IDM_EXIT:
            SendMessage(hwnd, WM_CLOSE, 0, 0L);
            break;

        case IDM_FAULT_1:
        case IDM_FAULT_2:
        case IDM_FAULT_3:
        case IDM_FAULT_4:
        case IDM_FAULT_5:
        case IDM_FAULT_6:
        case IDM_FAULT_7:
        case IDM_FAULT_8:
            Fault(wParam);
            return 0L;

        case IDM_NOTIFY_ENABLE:
            if (GetMenuState(GetMenu(hwnd), IDM_NOTIFY_ENABLE, 0) & MF_CHECKED)
            {
                wNotifyState = FALSE;
                CheckMenuItem(GetMenu(hwnd), IDM_NOTIFY_ENABLE, MF_UNCHECKED);
            }
            else
            {
                wNotifyState = TRUE;
                CheckMenuItem(GetMenu(hwnd), IDM_NOTIFY_ENABLE, MF_CHECKED);
            }
            return 0L;

        case IDM_FILTER_ENABLE:
            if (GetMenuState(GetMenu(hwnd), IDM_FILTER_ENABLE, 0) & MF_CHECKED)
            {
                wFilterState = FALSE;
                CheckMenuItem(GetMenu(hwnd), IDM_FILTER_ENABLE, MF_UNCHECKED);
            }
            else
            {
                wFilterState = TRUE;
                CheckMenuItem(GetMenu(hwnd), IDM_FILTER_ENABLE, MF_CHECKED);
            }
            return 0L;

        case IDM_NOTIFY_CLEAR:
            SendMessage(hwndListLocal, WM_SETREDRAW, FALSE, 0L);
            SendMessage(hwndListLocal, LB_RESETCONTENT, 0, 0L);
            SendMessage(hwndListLocal, WM_SETREDRAW, TRUE, 0L);
            InvalidateRect(hwndListLocal, NULL, TRUE);
            return 0L;
        }
        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hwnd, nMessage, wParam, lParam);
    }

    return 0L;
}

/*  MemWndProc
 *      Window proc for memory browser.
 */

LONG FAR PASCAL MemWndProc(
    HWND hwnd,
    int nMessage,
    WORD wParam,
    LONG lParam)
{
    CREATESTRUCT *lpCreate;
    GLOBALENTRY *pGlobal;
    WORD w;
    LPSTR lpBlock;
    RECT rect;
    HMENU hMenu;
    DWORD dwReturn;

    switch (nMessage)
    {
    case WM_CREATE:
        /* Save the block pointer as window WORD 0 */
        SetWindowWord(hwnd, MEM_BLOCK,
            LOWORD((LONG)((LPCREATESTRUCT)lParam)->lpCreateParams));

        /* Get information about this block */
        pGlobal = (GLOBALENTRY *)LocalAlloc(LMEM_FIXED, sizeof (GLOBALENTRY));
        if (!pGlobal)
        {
            PostMessage(hwnd, WM_CLOSE, 0, 0L);
            break;
        }
        pGlobal->dwSize = sizeof (GLOBALENTRY);
        if (!GlobalEntryHandle(pGlobal, GetWindowWord(hwnd, MEM_BLOCK)))
        {
            MessageBox(hwnd, "Block Handle is invalid", "Browser", IDOK);
            PostMessage(hwnd, WM_CLOSE, 0, 0L);
            break;
        }

        /* Save GLOBALENTRY pointer as window WORD 2 */
        SetWindowWord(hwnd, MEM_GLOBALENTRY, (WORD)pGlobal);

        /* Now read the memory into our global block */
        w = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, pGlobal->dwBlockSize);
        if (!w)
        {
            MessageBox(hwnd, "Not enough memory to copy block",
                "Browser", IDOK);
            PostMessage(hwnd, WM_CLOSE, 0, 0L);
            return 0L;
        }
        lpBlock = GlobalLock(w);
        SetWindowWord(hwnd, MEM_HOURBLOCK, w);
        SetWindowLong(hwnd, MEM_LPOURBLOCK, (LONG)lpBlock);
        MemoryRead(GetWindowWord(hwnd, MEM_BLOCK), 0L, lpBlock,
            pGlobal->dwBlockSize);

        /* Put a new item on the system menu to rewrite the block */
        hMenu = GetSystemMenu(hwnd, 0);
        AppendMenu(hMenu, MF_STRING, IDM_WRITE, "&Write");
        AppendMenu(hMenu, MF_STRING, IDM_WRITEBP, "Write &BP");

        break;

    case WM_SIZE:
    {
        SHORT nScrollMax;

        /* Compute the scroll bar maximum and position */
        pGlobal = (GLOBALENTRY *)GetWindowWord(hwnd, MEM_GLOBALENTRY);
        nScrollMax = MAXLINES(pGlobal->dwBlockSize, HIWORD(lParam));
        SetScrollRange(hwnd, SB_VERT, 0, nScrollMax, FALSE);
        SetScrollPos(hwnd, SB_VERT, min(GetScrollPos(hwnd, SB_VERT),
            nScrollMax), FALSE);

        /* Force the whole thing to repaint */
        InvalidateRect(hwnd, NULL, TRUE);
        break;
    }

    case WM_VSCROLL:
    {
        SHORT nScrollInc;
        SHORT nScrollPos;
        SHORT nScrollMin;
        SHORT nScrollMax;

        /* Get the current position */
        nScrollPos = GetScrollPos(hwnd, SB_VERT);
        GetScrollRange(hwnd, SB_VERT, &nScrollMin, &nScrollMax);
        GetClientRect(hwnd, &rect);

        /* Decode the various forms of scrolling */
        switch (wParam)
        {
        case SB_TOP:
            nScrollInc = -nScrollPos;
            break;

        case SB_BOTTOM:
            nScrollInc = nScrollMax - nScrollPos;
            break;

        case SB_LINEUP:
            nScrollInc = -1;
            break;

        case SB_LINEDOWN:
            nScrollInc = 1;
            break;

        case SB_PAGEUP:
            nScrollInc = min(-1, -rect.bottom / yChar);
            break;

        case SB_PAGEDOWN:
            nScrollInc = max(1, rect.bottom / yChar);
            break;

        case SB_THUMBTRACK:
            nScrollInc = LOWORD(lParam) - nScrollPos;
            break;

        default:
            nScrollInc = 0;
            break;
        }
        
        /* Now do the scroll */
        if (nScrollInc = max(-nScrollPos,
            min(nScrollInc, nScrollMax - nScrollPos)))
        {
            ScrollWindow(hwnd, 0, -yChar * nScrollInc, NULL, NULL);
            SetScrollPos(hwnd, SB_VERT, nScrollPos + nScrollInc, TRUE);
            UpdateWindow(hwnd);
        }
        break;
    }

    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        SHORT nScrollMin;
        SHORT nScrollMax;
        SHORT nScrollPos;
        SHORT nStart;
        SHORT nEnd;
        HFONT hFont;
        HFONT hOldFont;

        BeginPaint(hwnd, &ps);

        /* Compute the number of lines to paint */
        pGlobal = (GLOBALENTRY *)GetWindowWord(hwnd, MEM_GLOBALENTRY);
        nScrollPos = GetScrollPos(hwnd, SB_VERT);
        GetScrollRange(hwnd, SB_VERT, &nScrollMin, &nScrollMax);
        nStart = max(0, nScrollPos + ps.rcPaint.top / yChar - 1);
        nEnd = min((SHORT)(pGlobal->dwBlockSize / 16) + 1,
            nScrollPos + ps.rcPaint.bottom / yChar + 1);

        /* Get a font to use */
   		hFont = GetStockObject(SYSTEM_FIXED_FONT);
		hOldFont = SelectObject(ps.hdc, hFont);

        /* Loop through and draw all lines */
        for (; nStart < nEnd ; ++nStart)
            DumpMem(hwnd, ps.hdc, nScrollPos, nStart);

		/* Delete the font that is no longer needed */
		DeleteObject(SelectObject(ps.hdc, hOldFont));

        EndPaint(hwnd, &ps);
        break;
    }

    case WM_DESTROY:
        /* Free memory associated with this window */
        LocalFree(GetWindowWord(hwnd, MEM_GLOBALENTRY));
        w = GetWindowWord(hwnd, MEM_HOURBLOCK);
        GlobalUnlock(w);
        GlobalFree(w);
        return 0L;

    case WM_COMMAND:
        switch (wParam)
        {
        case 1:     /* Close button */
			SendMessage(hwnd, WM_CLOSE, 0, 0L);
            return 0L;

        case 2:     /* Write button */
            return 0L;

        default:
            return DefWindowProc(hwnd, nMessage, wParam, lParam);
        }

    case WM_SYSCOMMAND:
        if (wParam == IDM_WRITE)
        {
            /* Write the block */
            pGlobal = (GLOBALENTRY *)GetWindowWord(hwnd, MEM_GLOBALENTRY);
            lpBlock = (LPSTR)GetWindowLong(hwnd, MEM_LPOURBLOCK);
            dwReturn = MemoryWrite(GetWindowWord(hwnd, MEM_BLOCK),
                0L, lpBlock, pGlobal->dwBlockSize);
            wsprintf(szText, "%lXh bytes written", dwReturn);
            MessageBox(hwnd, szText, "Memory Browser Write", MB_OK);
            InvalidateRect(hwnd, NULL, TRUE);
            break;
        }
        else if (wParam == IDM_WRITEBP)
        {
            /* Write the breakpoint only if it's code */
            pGlobal = (GLOBALENTRY *)GetWindowWord(hwnd, MEM_GLOBALENTRY);
            if (pGlobal->wType != GT_CODE)
            {
                MessageBox(hwnd, "Breakpoints only go in code segments",
                    "Memory Browser Breakpoint", MB_OK);
                return 0L;
            }
            lpBlock = (LPSTR)GetWindowLong(hwnd, MEM_LPOURBLOCK);
            *lpBlock = 0xcc;
            dwReturn = MemoryWrite(GetWindowWord(hwnd, MEM_BLOCK),
                0L, lpBlock, 1);
            wsprintf(szText, "%lXh bytes written", dwReturn);
            MessageBox(hwnd, szText, "Memory Browser Write", MB_OK);
            InvalidateRect(hwnd, NULL, TRUE);
            break;
        }
        else
            return DefWindowProc(hwnd, nMessage, wParam, lParam);

    default:
        return DefWindowProc(hwnd, nMessage, wParam, lParam);
    }

    return 0L;
}


/*  DumpMem
 *      Dumps memory to the memory window.  This routine is called once
 *      per memory line to dump in the middle of the paint message.
 */

void PASCAL DumpMem(
    HWND hwnd,
    HDC hDC,
    SHORT nScrollPos,
    SHORT nPos)
{
    LPSTR lpMem;
    DWORD dwOffset;
    WORD i;
    PSTR pstr;
    BYTE by;
    BYTE byCount;
    BYTE byBadCount;
    GLOBALENTRY *pGlobal;

    /* Get a pointer to the memory */
    dwOffset = ((DWORD)(WORD)nPos) << 4;
    lpMem = (LPSTR)MAKELONG(LOWORD(dwOffset),
        GetWindowWord(hwnd, MEM_LPOURBLOCK + 2) +
        HIWORD(dwOffset) * (WORD)&_AHINCR);

    /* How many real characters are there to draw? */
    pGlobal = (GLOBALENTRY *)GetWindowWord(hwnd, MEM_GLOBALENTRY);
    if (pGlobal->dwBlockSize < dwOffset + 16)
    {
        if (pGlobal->dwBlockSize < dwOffset)
        {
            byCount = 0;
            byBadCount = 16;
        }
        else
        {
            byCount = pGlobal->dwBlockSize - dwOffset;
            byBadCount = 16 - byCount;
        }
    }
    else
    {
        byCount = 16;
        byBadCount = 0;
    }

    /* Put into a string so we can see it */
    pstr = szText;
    pstr += wsprintf(pstr, "%06lX:", dwOffset);
    for (i = 0 ; i < byCount ; ++i)
        pstr += wsprintf(pstr, "%02X ",
            (WORD)*(unsigned char FAR *)(lpMem + i));
    for (i = 0 ; i < byBadCount ; ++i)
        pstr += wsprintf(pstr, "?? ");
    for (i = 0 ; i < byCount ; ++i)
    {
        by = *(lpMem + i);
        pstr += wsprintf(pstr, "%c", by >= ' ' ? by : '.');
    }
    for (i = 0 ; i < byBadCount ; ++i)
        pstr += wsprintf(pstr, "?");

    /* Draw the text */
    TextOut(hDC, xChar, yChar * (nPos - nScrollPos), szText,
        strlen(szText));
}


/*  WalkGlobalHeap
 *      Walks the global heap in the list box.  Returns the WndProc return
 *      value.
 */

LONG WalkGlobalHeap(
    HWND hwnd)
{
    GLOBALINFO GlobalInf;
    GLOBALENTRY Global;
    MODULEENTRY Module;
    TASKENTRY Task;
    char *npText;
    char *npstr;
    int i;
    HCURSOR hCursor;

    /* Turn on the hourglass */
    hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
    ShowCursor(TRUE);
    wListStatus = LIST_GLOBAL;

    /* Allocate a buffer to store this stuff in.  Pad this number
     *  because the LocalAlloc corrupts the walk.
     */
    GlobalInf.dwSize = sizeof (GLOBALINFO);
    GlobalInfo(&GlobalInf);
    npText = npstr = (char *)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
        (GlobalInf.wcItems + 10) * (LIST_WIDTH + 1));
    if (!npText)
        return 0L;

    /* Loop through the global heap */
    Global.dwSize = sizeof (GLOBALENTRY);
    Module.dwSize = sizeof (MODULEENTRY);
    Task.dwSize = sizeof (TASKENTRY);
    if (GlobalFirst(&Global, GLOBAL_ALL))
    {
        char temp[30];

        i = 0;
        do
        {
            /* Get the module name */
            if (!Global.hOwner)
                lstrcpy(Module.szModule, "FREE");
            else if (!ModuleFindHandle(&Module, Global.hOwner))
            {
                if (TaskFindHandle(&Task, Global.hOwner))
                    lstrcpy(Module.szModule, Task.szModule);
                else
                    *Module.szModule = '\0';
            }